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

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

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

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

> source("incl/start.R")
[17:26:34.541] plan(): Setting new future strategy stack:
[17:26:34.542] List of future strategies:
[17:26:34.542] 1. sequential:
[17:26:34.542]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:34.542]    - tweaked: FALSE
[17:26:34.542]    - call: future::plan("sequential")
[17:26:34.557] 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:26:34.624] plan(): Setting new future strategy stack:
[17:26:34.624] List of future strategies:
[17:26:34.624] 1. sequential:
[17:26:34.624]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:34.624]    - tweaked: FALSE
[17:26:34.624]    - call: plan(strategy)
[17:26:34.637] plan(): nbrOfWorkers() = 1
** Future evaluation without globals
[17:26:34.639] getGlobalsAndPackages() ...
[17:26:34.639] Searching for globals...
[17:26:34.644] - globals found: [2] '{', '<-'
[17:26:34.644] Searching for globals ... DONE
[17:26:34.645] Resolving globals: FALSE
[17:26:34.645] 
[17:26:34.645] 
[17:26:34.646] getGlobalsAndPackages() ... DONE
[17:26:34.646] run() for 'Future' ...
[17:26:34.647] - state: 'created'
[17:26:34.647] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:34.647] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:34.647] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:34.648]   - Field: 'label'
[17:26:34.648]   - Field: 'local'
[17:26:34.648]   - Field: 'owner'
[17:26:34.648]   - Field: 'envir'
[17:26:34.648]   - Field: 'packages'
[17:26:34.649]   - Field: 'gc'
[17:26:34.649]   - Field: 'conditions'
[17:26:34.649]   - Field: 'expr'
[17:26:34.649]   - Field: 'uuid'
[17:26:34.649]   - Field: 'seed'
[17:26:34.649]   - Field: 'version'
[17:26:34.650]   - Field: 'result'
[17:26:34.650]   - Field: 'asynchronous'
[17:26:34.650]   - Field: 'calls'
[17:26:34.650]   - Field: 'globals'
[17:26:34.650]   - Field: 'stdout'
[17:26:34.650]   - Field: 'earlySignal'
[17:26:34.651]   - Field: 'lazy'
[17:26:34.651]   - Field: 'state'
[17:26:34.651] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:34.651] - Launch lazy future ...
[17:26:34.652] Packages needed by the future expression (n = 0): <none>
[17:26:34.652] Packages needed by future strategies (n = 0): <none>
[17:26:34.653] {
[17:26:34.653]     {
[17:26:34.653]         {
[17:26:34.653]             ...future.startTime <- base::Sys.time()
[17:26:34.653]             {
[17:26:34.653]                 {
[17:26:34.653]                   {
[17:26:34.653]                     base::local({
[17:26:34.653]                       has_future <- base::requireNamespace("future", 
[17:26:34.653]                         quietly = TRUE)
[17:26:34.653]                       if (has_future) {
[17:26:34.653]                         ns <- base::getNamespace("future")
[17:26:34.653]                         version <- ns[[".package"]][["version"]]
[17:26:34.653]                         if (is.null(version)) 
[17:26:34.653]                           version <- utils::packageVersion("future")
[17:26:34.653]                       }
[17:26:34.653]                       else {
[17:26:34.653]                         version <- NULL
[17:26:34.653]                       }
[17:26:34.653]                       if (!has_future || version < "1.8.0") {
[17:26:34.653]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:34.653]                           "", base::R.version$version.string), 
[17:26:34.653]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:34.653]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:34.653]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:34.653]                             "release", "version")], collapse = " "), 
[17:26:34.653]                           hostname = base::Sys.info()[["nodename"]])
[17:26:34.653]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:34.653]                           info)
[17:26:34.653]                         info <- base::paste(info, collapse = "; ")
[17:26:34.653]                         if (!has_future) {
[17:26:34.653]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:34.653]                             info)
[17:26:34.653]                         }
[17:26:34.653]                         else {
[17:26:34.653]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:34.653]                             info, version)
[17:26:34.653]                         }
[17:26:34.653]                         base::stop(msg)
[17:26:34.653]                       }
[17:26:34.653]                     })
[17:26:34.653]                   }
[17:26:34.653]                   ...future.strategy.old <- future::plan("list")
[17:26:34.653]                   options(future.plan = NULL)
[17:26:34.653]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:34.653]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:34.653]                 }
[17:26:34.653]                 ...future.workdir <- getwd()
[17:26:34.653]             }
[17:26:34.653]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:34.653]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:34.653]         }
[17:26:34.653]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:34.653]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:34.653]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:34.653]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:34.653]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:34.653]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:34.653]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:34.653]             base::names(...future.oldOptions))
[17:26:34.653]     }
[17:26:34.653]     if (FALSE) {
[17:26:34.653]     }
[17:26:34.653]     else {
[17:26:34.653]         if (TRUE) {
[17:26:34.653]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:34.653]                 open = "w")
[17:26:34.653]         }
[17:26:34.653]         else {
[17:26:34.653]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:34.653]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:34.653]         }
[17:26:34.653]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:34.653]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:34.653]             base::sink(type = "output", split = FALSE)
[17:26:34.653]             base::close(...future.stdout)
[17:26:34.653]         }, add = TRUE)
[17:26:34.653]     }
[17:26:34.653]     ...future.frame <- base::sys.nframe()
[17:26:34.653]     ...future.conditions <- base::list()
[17:26:34.653]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:34.653]     if (FALSE) {
[17:26:34.653]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:34.653]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:34.653]     }
[17:26:34.653]     ...future.result <- base::tryCatch({
[17:26:34.653]         base::withCallingHandlers({
[17:26:34.653]             ...future.value <- base::withVisible(base::local({
[17:26:34.653]                 x <- 1
[17:26:34.653]             }))
[17:26:34.653]             future::FutureResult(value = ...future.value$value, 
[17:26:34.653]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:34.653]                   ...future.rng), globalenv = if (FALSE) 
[17:26:34.653]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:34.653]                     ...future.globalenv.names))
[17:26:34.653]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:34.653]         }, condition = base::local({
[17:26:34.653]             c <- base::c
[17:26:34.653]             inherits <- base::inherits
[17:26:34.653]             invokeRestart <- base::invokeRestart
[17:26:34.653]             length <- base::length
[17:26:34.653]             list <- base::list
[17:26:34.653]             seq.int <- base::seq.int
[17:26:34.653]             signalCondition <- base::signalCondition
[17:26:34.653]             sys.calls <- base::sys.calls
[17:26:34.653]             `[[` <- base::`[[`
[17:26:34.653]             `+` <- base::`+`
[17:26:34.653]             `<<-` <- base::`<<-`
[17:26:34.653]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:34.653]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:34.653]                   3L)]
[17:26:34.653]             }
[17:26:34.653]             function(cond) {
[17:26:34.653]                 is_error <- inherits(cond, "error")
[17:26:34.653]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:34.653]                   NULL)
[17:26:34.653]                 if (is_error) {
[17:26:34.653]                   sessionInformation <- function() {
[17:26:34.653]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:34.653]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:34.653]                       search = base::search(), system = base::Sys.info())
[17:26:34.653]                   }
[17:26:34.653]                   ...future.conditions[[length(...future.conditions) + 
[17:26:34.653]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:34.653]                     cond$call), session = sessionInformation(), 
[17:26:34.653]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:34.653]                   signalCondition(cond)
[17:26:34.653]                 }
[17:26:34.653]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:34.653]                 "immediateCondition"))) {
[17:26:34.653]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:34.653]                   ...future.conditions[[length(...future.conditions) + 
[17:26:34.653]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:34.653]                   if (TRUE && !signal) {
[17:26:34.653]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.653]                     {
[17:26:34.653]                       inherits <- base::inherits
[17:26:34.653]                       invokeRestart <- base::invokeRestart
[17:26:34.653]                       is.null <- base::is.null
[17:26:34.653]                       muffled <- FALSE
[17:26:34.653]                       if (inherits(cond, "message")) {
[17:26:34.653]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:34.653]                         if (muffled) 
[17:26:34.653]                           invokeRestart("muffleMessage")
[17:26:34.653]                       }
[17:26:34.653]                       else if (inherits(cond, "warning")) {
[17:26:34.653]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:34.653]                         if (muffled) 
[17:26:34.653]                           invokeRestart("muffleWarning")
[17:26:34.653]                       }
[17:26:34.653]                       else if (inherits(cond, "condition")) {
[17:26:34.653]                         if (!is.null(pattern)) {
[17:26:34.653]                           computeRestarts <- base::computeRestarts
[17:26:34.653]                           grepl <- base::grepl
[17:26:34.653]                           restarts <- computeRestarts(cond)
[17:26:34.653]                           for (restart in restarts) {
[17:26:34.653]                             name <- restart$name
[17:26:34.653]                             if (is.null(name)) 
[17:26:34.653]                               next
[17:26:34.653]                             if (!grepl(pattern, name)) 
[17:26:34.653]                               next
[17:26:34.653]                             invokeRestart(restart)
[17:26:34.653]                             muffled <- TRUE
[17:26:34.653]                             break
[17:26:34.653]                           }
[17:26:34.653]                         }
[17:26:34.653]                       }
[17:26:34.653]                       invisible(muffled)
[17:26:34.653]                     }
[17:26:34.653]                     muffleCondition(cond, pattern = "^muffle")
[17:26:34.653]                   }
[17:26:34.653]                 }
[17:26:34.653]                 else {
[17:26:34.653]                   if (TRUE) {
[17:26:34.653]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.653]                     {
[17:26:34.653]                       inherits <- base::inherits
[17:26:34.653]                       invokeRestart <- base::invokeRestart
[17:26:34.653]                       is.null <- base::is.null
[17:26:34.653]                       muffled <- FALSE
[17:26:34.653]                       if (inherits(cond, "message")) {
[17:26:34.653]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:34.653]                         if (muffled) 
[17:26:34.653]                           invokeRestart("muffleMessage")
[17:26:34.653]                       }
[17:26:34.653]                       else if (inherits(cond, "warning")) {
[17:26:34.653]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:34.653]                         if (muffled) 
[17:26:34.653]                           invokeRestart("muffleWarning")
[17:26:34.653]                       }
[17:26:34.653]                       else if (inherits(cond, "condition")) {
[17:26:34.653]                         if (!is.null(pattern)) {
[17:26:34.653]                           computeRestarts <- base::computeRestarts
[17:26:34.653]                           grepl <- base::grepl
[17:26:34.653]                           restarts <- computeRestarts(cond)
[17:26:34.653]                           for (restart in restarts) {
[17:26:34.653]                             name <- restart$name
[17:26:34.653]                             if (is.null(name)) 
[17:26:34.653]                               next
[17:26:34.653]                             if (!grepl(pattern, name)) 
[17:26:34.653]                               next
[17:26:34.653]                             invokeRestart(restart)
[17:26:34.653]                             muffled <- TRUE
[17:26:34.653]                             break
[17:26:34.653]                           }
[17:26:34.653]                         }
[17:26:34.653]                       }
[17:26:34.653]                       invisible(muffled)
[17:26:34.653]                     }
[17:26:34.653]                     muffleCondition(cond, pattern = "^muffle")
[17:26:34.653]                   }
[17:26:34.653]                 }
[17:26:34.653]             }
[17:26:34.653]         }))
[17:26:34.653]     }, error = function(ex) {
[17:26:34.653]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:34.653]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:34.653]                 ...future.rng), started = ...future.startTime, 
[17:26:34.653]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:34.653]             version = "1.8"), class = "FutureResult")
[17:26:34.653]     }, finally = {
[17:26:34.653]         if (!identical(...future.workdir, getwd())) 
[17:26:34.653]             setwd(...future.workdir)
[17:26:34.653]         {
[17:26:34.653]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:34.653]                 ...future.oldOptions$nwarnings <- NULL
[17:26:34.653]             }
[17:26:34.653]             base::options(...future.oldOptions)
[17:26:34.653]             if (.Platform$OS.type == "windows") {
[17:26:34.653]                 old_names <- names(...future.oldEnvVars)
[17:26:34.653]                 envs <- base::Sys.getenv()
[17:26:34.653]                 names <- names(envs)
[17:26:34.653]                 common <- intersect(names, old_names)
[17:26:34.653]                 added <- setdiff(names, old_names)
[17:26:34.653]                 removed <- setdiff(old_names, names)
[17:26:34.653]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:34.653]                   envs[common]]
[17:26:34.653]                 NAMES <- toupper(changed)
[17:26:34.653]                 args <- list()
[17:26:34.653]                 for (kk in seq_along(NAMES)) {
[17:26:34.653]                   name <- changed[[kk]]
[17:26:34.653]                   NAME <- NAMES[[kk]]
[17:26:34.653]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.653]                     next
[17:26:34.653]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:34.653]                 }
[17:26:34.653]                 NAMES <- toupper(added)
[17:26:34.653]                 for (kk in seq_along(NAMES)) {
[17:26:34.653]                   name <- added[[kk]]
[17:26:34.653]                   NAME <- NAMES[[kk]]
[17:26:34.653]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.653]                     next
[17:26:34.653]                   args[[name]] <- ""
[17:26:34.653]                 }
[17:26:34.653]                 NAMES <- toupper(removed)
[17:26:34.653]                 for (kk in seq_along(NAMES)) {
[17:26:34.653]                   name <- removed[[kk]]
[17:26:34.653]                   NAME <- NAMES[[kk]]
[17:26:34.653]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.653]                     next
[17:26:34.653]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:34.653]                 }
[17:26:34.653]                 if (length(args) > 0) 
[17:26:34.653]                   base::do.call(base::Sys.setenv, args = args)
[17:26:34.653]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:34.653]             }
[17:26:34.653]             else {
[17:26:34.653]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:34.653]             }
[17:26:34.653]             {
[17:26:34.653]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:34.653]                   0L) {
[17:26:34.653]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:34.653]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:34.653]                   base::options(opts)
[17:26:34.653]                 }
[17:26:34.653]                 {
[17:26:34.653]                   {
[17:26:34.653]                     NULL
[17:26:34.653]                     RNGkind("Mersenne-Twister")
[17:26:34.653]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:34.653]                       inherits = FALSE)
[17:26:34.653]                   }
[17:26:34.653]                   options(future.plan = NULL)
[17:26:34.653]                   if (is.na(NA_character_)) 
[17:26:34.653]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:34.653]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:34.653]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:34.653]                     .init = FALSE)
[17:26:34.653]                 }
[17:26:34.653]             }
[17:26:34.653]         }
[17:26:34.653]     })
[17:26:34.653]     if (TRUE) {
[17:26:34.653]         base::sink(type = "output", split = FALSE)
[17:26:34.653]         if (TRUE) {
[17:26:34.653]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:34.653]         }
[17:26:34.653]         else {
[17:26:34.653]             ...future.result["stdout"] <- base::list(NULL)
[17:26:34.653]         }
[17:26:34.653]         base::close(...future.stdout)
[17:26:34.653]         ...future.stdout <- NULL
[17:26:34.653]     }
[17:26:34.653]     ...future.result$conditions <- ...future.conditions
[17:26:34.653]     ...future.result$finished <- base::Sys.time()
[17:26:34.653]     ...future.result
[17:26:34.653] }
[17:26:34.657] plan(): Setting new future strategy stack:
[17:26:34.657] List of future strategies:
[17:26:34.657] 1. sequential:
[17:26:34.657]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:34.657]    - tweaked: FALSE
[17:26:34.657]    - call: NULL
[17:26:34.658] plan(): nbrOfWorkers() = 1
[17:26:34.660] plan(): Setting new future strategy stack:
[17:26:34.660] List of future strategies:
[17:26:34.660] 1. sequential:
[17:26:34.660]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:34.660]    - tweaked: FALSE
[17:26:34.660]    - call: plan(strategy)
[17:26:34.661] plan(): nbrOfWorkers() = 1
[17:26:34.661] SequentialFuture started (and completed)
[17:26:34.662] - Launch lazy future ... done
[17:26:34.662] run() for 'SequentialFuture' ... done
** Future evaluation with globals
[17:26:34.663] getGlobalsAndPackages() ...
[17:26:34.663] Searching for globals...
[17:26:34.664] - globals found: [3] '{', '<-', 'a'
[17:26:34.664] Searching for globals ... DONE
[17:26:34.664] Resolving globals: FALSE
[17:26:34.665] The total size of the 1 globals is 56 bytes (56 bytes)
[17:26:34.666] The total size of the 1 globals exported for future expression ('{; x <- a; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'a' (56 bytes of class 'numeric')
[17:26:34.666] - globals: [1] 'a'
[17:26:34.666] 
[17:26:34.666] getGlobalsAndPackages() ... DONE
[17:26:34.667] run() for 'Future' ...
[17:26:34.667] - state: 'created'
[17:26:34.667] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:34.668] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:34.668] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:34.668]   - Field: 'label'
[17:26:34.668]   - Field: 'local'
[17:26:34.668]   - Field: 'owner'
[17:26:34.668]   - Field: 'envir'
[17:26:34.669]   - Field: 'packages'
[17:26:34.669]   - Field: 'gc'
[17:26:34.669]   - Field: 'conditions'
[17:26:34.669]   - Field: 'expr'
[17:26:34.669]   - Field: 'uuid'
[17:26:34.669]   - Field: 'seed'
[17:26:34.670]   - Field: 'version'
[17:26:34.670]   - Field: 'result'
[17:26:34.670]   - Field: 'asynchronous'
[17:26:34.670]   - Field: 'calls'
[17:26:34.670]   - Field: 'globals'
[17:26:34.671]   - Field: 'stdout'
[17:26:34.671]   - Field: 'earlySignal'
[17:26:34.671]   - Field: 'lazy'
[17:26:34.671]   - Field: 'state'
[17:26:34.671] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:34.671] - Launch lazy future ...
[17:26:34.672] Packages needed by the future expression (n = 0): <none>
[17:26:34.672] Packages needed by future strategies (n = 0): <none>
[17:26:34.672] {
[17:26:34.672]     {
[17:26:34.672]         {
[17:26:34.672]             ...future.startTime <- base::Sys.time()
[17:26:34.672]             {
[17:26:34.672]                 {
[17:26:34.672]                   {
[17:26:34.672]                     base::local({
[17:26:34.672]                       has_future <- base::requireNamespace("future", 
[17:26:34.672]                         quietly = TRUE)
[17:26:34.672]                       if (has_future) {
[17:26:34.672]                         ns <- base::getNamespace("future")
[17:26:34.672]                         version <- ns[[".package"]][["version"]]
[17:26:34.672]                         if (is.null(version)) 
[17:26:34.672]                           version <- utils::packageVersion("future")
[17:26:34.672]                       }
[17:26:34.672]                       else {
[17:26:34.672]                         version <- NULL
[17:26:34.672]                       }
[17:26:34.672]                       if (!has_future || version < "1.8.0") {
[17:26:34.672]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:34.672]                           "", base::R.version$version.string), 
[17:26:34.672]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:34.672]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:34.672]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:34.672]                             "release", "version")], collapse = " "), 
[17:26:34.672]                           hostname = base::Sys.info()[["nodename"]])
[17:26:34.672]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:34.672]                           info)
[17:26:34.672]                         info <- base::paste(info, collapse = "; ")
[17:26:34.672]                         if (!has_future) {
[17:26:34.672]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:34.672]                             info)
[17:26:34.672]                         }
[17:26:34.672]                         else {
[17:26:34.672]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:34.672]                             info, version)
[17:26:34.672]                         }
[17:26:34.672]                         base::stop(msg)
[17:26:34.672]                       }
[17:26:34.672]                     })
[17:26:34.672]                   }
[17:26:34.672]                   ...future.strategy.old <- future::plan("list")
[17:26:34.672]                   options(future.plan = NULL)
[17:26:34.672]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:34.672]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:34.672]                 }
[17:26:34.672]                 ...future.workdir <- getwd()
[17:26:34.672]             }
[17:26:34.672]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:34.672]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:34.672]         }
[17:26:34.672]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:34.672]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:34.672]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:34.672]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:34.672]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:34.672]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:34.672]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:34.672]             base::names(...future.oldOptions))
[17:26:34.672]     }
[17:26:34.672]     if (FALSE) {
[17:26:34.672]     }
[17:26:34.672]     else {
[17:26:34.672]         if (TRUE) {
[17:26:34.672]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:34.672]                 open = "w")
[17:26:34.672]         }
[17:26:34.672]         else {
[17:26:34.672]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:34.672]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:34.672]         }
[17:26:34.672]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:34.672]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:34.672]             base::sink(type = "output", split = FALSE)
[17:26:34.672]             base::close(...future.stdout)
[17:26:34.672]         }, add = TRUE)
[17:26:34.672]     }
[17:26:34.672]     ...future.frame <- base::sys.nframe()
[17:26:34.672]     ...future.conditions <- base::list()
[17:26:34.672]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:34.672]     if (FALSE) {
[17:26:34.672]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:34.672]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:34.672]     }
[17:26:34.672]     ...future.result <- base::tryCatch({
[17:26:34.672]         base::withCallingHandlers({
[17:26:34.672]             ...future.value <- base::withVisible(base::local({
[17:26:34.672]                 x <- a
[17:26:34.672]             }))
[17:26:34.672]             future::FutureResult(value = ...future.value$value, 
[17:26:34.672]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:34.672]                   ...future.rng), globalenv = if (FALSE) 
[17:26:34.672]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:34.672]                     ...future.globalenv.names))
[17:26:34.672]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:34.672]         }, condition = base::local({
[17:26:34.672]             c <- base::c
[17:26:34.672]             inherits <- base::inherits
[17:26:34.672]             invokeRestart <- base::invokeRestart
[17:26:34.672]             length <- base::length
[17:26:34.672]             list <- base::list
[17:26:34.672]             seq.int <- base::seq.int
[17:26:34.672]             signalCondition <- base::signalCondition
[17:26:34.672]             sys.calls <- base::sys.calls
[17:26:34.672]             `[[` <- base::`[[`
[17:26:34.672]             `+` <- base::`+`
[17:26:34.672]             `<<-` <- base::`<<-`
[17:26:34.672]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:34.672]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:34.672]                   3L)]
[17:26:34.672]             }
[17:26:34.672]             function(cond) {
[17:26:34.672]                 is_error <- inherits(cond, "error")
[17:26:34.672]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:34.672]                   NULL)
[17:26:34.672]                 if (is_error) {
[17:26:34.672]                   sessionInformation <- function() {
[17:26:34.672]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:34.672]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:34.672]                       search = base::search(), system = base::Sys.info())
[17:26:34.672]                   }
[17:26:34.672]                   ...future.conditions[[length(...future.conditions) + 
[17:26:34.672]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:34.672]                     cond$call), session = sessionInformation(), 
[17:26:34.672]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:34.672]                   signalCondition(cond)
[17:26:34.672]                 }
[17:26:34.672]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:34.672]                 "immediateCondition"))) {
[17:26:34.672]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:34.672]                   ...future.conditions[[length(...future.conditions) + 
[17:26:34.672]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:34.672]                   if (TRUE && !signal) {
[17:26:34.672]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.672]                     {
[17:26:34.672]                       inherits <- base::inherits
[17:26:34.672]                       invokeRestart <- base::invokeRestart
[17:26:34.672]                       is.null <- base::is.null
[17:26:34.672]                       muffled <- FALSE
[17:26:34.672]                       if (inherits(cond, "message")) {
[17:26:34.672]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:34.672]                         if (muffled) 
[17:26:34.672]                           invokeRestart("muffleMessage")
[17:26:34.672]                       }
[17:26:34.672]                       else if (inherits(cond, "warning")) {
[17:26:34.672]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:34.672]                         if (muffled) 
[17:26:34.672]                           invokeRestart("muffleWarning")
[17:26:34.672]                       }
[17:26:34.672]                       else if (inherits(cond, "condition")) {
[17:26:34.672]                         if (!is.null(pattern)) {
[17:26:34.672]                           computeRestarts <- base::computeRestarts
[17:26:34.672]                           grepl <- base::grepl
[17:26:34.672]                           restarts <- computeRestarts(cond)
[17:26:34.672]                           for (restart in restarts) {
[17:26:34.672]                             name <- restart$name
[17:26:34.672]                             if (is.null(name)) 
[17:26:34.672]                               next
[17:26:34.672]                             if (!grepl(pattern, name)) 
[17:26:34.672]                               next
[17:26:34.672]                             invokeRestart(restart)
[17:26:34.672]                             muffled <- TRUE
[17:26:34.672]                             break
[17:26:34.672]                           }
[17:26:34.672]                         }
[17:26:34.672]                       }
[17:26:34.672]                       invisible(muffled)
[17:26:34.672]                     }
[17:26:34.672]                     muffleCondition(cond, pattern = "^muffle")
[17:26:34.672]                   }
[17:26:34.672]                 }
[17:26:34.672]                 else {
[17:26:34.672]                   if (TRUE) {
[17:26:34.672]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.672]                     {
[17:26:34.672]                       inherits <- base::inherits
[17:26:34.672]                       invokeRestart <- base::invokeRestart
[17:26:34.672]                       is.null <- base::is.null
[17:26:34.672]                       muffled <- FALSE
[17:26:34.672]                       if (inherits(cond, "message")) {
[17:26:34.672]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:34.672]                         if (muffled) 
[17:26:34.672]                           invokeRestart("muffleMessage")
[17:26:34.672]                       }
[17:26:34.672]                       else if (inherits(cond, "warning")) {
[17:26:34.672]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:34.672]                         if (muffled) 
[17:26:34.672]                           invokeRestart("muffleWarning")
[17:26:34.672]                       }
[17:26:34.672]                       else if (inherits(cond, "condition")) {
[17:26:34.672]                         if (!is.null(pattern)) {
[17:26:34.672]                           computeRestarts <- base::computeRestarts
[17:26:34.672]                           grepl <- base::grepl
[17:26:34.672]                           restarts <- computeRestarts(cond)
[17:26:34.672]                           for (restart in restarts) {
[17:26:34.672]                             name <- restart$name
[17:26:34.672]                             if (is.null(name)) 
[17:26:34.672]                               next
[17:26:34.672]                             if (!grepl(pattern, name)) 
[17:26:34.672]                               next
[17:26:34.672]                             invokeRestart(restart)
[17:26:34.672]                             muffled <- TRUE
[17:26:34.672]                             break
[17:26:34.672]                           }
[17:26:34.672]                         }
[17:26:34.672]                       }
[17:26:34.672]                       invisible(muffled)
[17:26:34.672]                     }
[17:26:34.672]                     muffleCondition(cond, pattern = "^muffle")
[17:26:34.672]                   }
[17:26:34.672]                 }
[17:26:34.672]             }
[17:26:34.672]         }))
[17:26:34.672]     }, error = function(ex) {
[17:26:34.672]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:34.672]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:34.672]                 ...future.rng), started = ...future.startTime, 
[17:26:34.672]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:34.672]             version = "1.8"), class = "FutureResult")
[17:26:34.672]     }, finally = {
[17:26:34.672]         if (!identical(...future.workdir, getwd())) 
[17:26:34.672]             setwd(...future.workdir)
[17:26:34.672]         {
[17:26:34.672]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:34.672]                 ...future.oldOptions$nwarnings <- NULL
[17:26:34.672]             }
[17:26:34.672]             base::options(...future.oldOptions)
[17:26:34.672]             if (.Platform$OS.type == "windows") {
[17:26:34.672]                 old_names <- names(...future.oldEnvVars)
[17:26:34.672]                 envs <- base::Sys.getenv()
[17:26:34.672]                 names <- names(envs)
[17:26:34.672]                 common <- intersect(names, old_names)
[17:26:34.672]                 added <- setdiff(names, old_names)
[17:26:34.672]                 removed <- setdiff(old_names, names)
[17:26:34.672]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:34.672]                   envs[common]]
[17:26:34.672]                 NAMES <- toupper(changed)
[17:26:34.672]                 args <- list()
[17:26:34.672]                 for (kk in seq_along(NAMES)) {
[17:26:34.672]                   name <- changed[[kk]]
[17:26:34.672]                   NAME <- NAMES[[kk]]
[17:26:34.672]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.672]                     next
[17:26:34.672]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:34.672]                 }
[17:26:34.672]                 NAMES <- toupper(added)
[17:26:34.672]                 for (kk in seq_along(NAMES)) {
[17:26:34.672]                   name <- added[[kk]]
[17:26:34.672]                   NAME <- NAMES[[kk]]
[17:26:34.672]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.672]                     next
[17:26:34.672]                   args[[name]] <- ""
[17:26:34.672]                 }
[17:26:34.672]                 NAMES <- toupper(removed)
[17:26:34.672]                 for (kk in seq_along(NAMES)) {
[17:26:34.672]                   name <- removed[[kk]]
[17:26:34.672]                   NAME <- NAMES[[kk]]
[17:26:34.672]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.672]                     next
[17:26:34.672]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:34.672]                 }
[17:26:34.672]                 if (length(args) > 0) 
[17:26:34.672]                   base::do.call(base::Sys.setenv, args = args)
[17:26:34.672]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:34.672]             }
[17:26:34.672]             else {
[17:26:34.672]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:34.672]             }
[17:26:34.672]             {
[17:26:34.672]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:34.672]                   0L) {
[17:26:34.672]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:34.672]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:34.672]                   base::options(opts)
[17:26:34.672]                 }
[17:26:34.672]                 {
[17:26:34.672]                   {
[17:26:34.672]                     NULL
[17:26:34.672]                     RNGkind("Mersenne-Twister")
[17:26:34.672]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:34.672]                       inherits = FALSE)
[17:26:34.672]                   }
[17:26:34.672]                   options(future.plan = NULL)
[17:26:34.672]                   if (is.na(NA_character_)) 
[17:26:34.672]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:34.672]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:34.672]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:34.672]                     .init = FALSE)
[17:26:34.672]                 }
[17:26:34.672]             }
[17:26:34.672]         }
[17:26:34.672]     })
[17:26:34.672]     if (TRUE) {
[17:26:34.672]         base::sink(type = "output", split = FALSE)
[17:26:34.672]         if (TRUE) {
[17:26:34.672]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:34.672]         }
[17:26:34.672]         else {
[17:26:34.672]             ...future.result["stdout"] <- base::list(NULL)
[17:26:34.672]         }
[17:26:34.672]         base::close(...future.stdout)
[17:26:34.672]         ...future.stdout <- NULL
[17:26:34.672]     }
[17:26:34.672]     ...future.result$conditions <- ...future.conditions
[17:26:34.672]     ...future.result$finished <- base::Sys.time()
[17:26:34.672]     ...future.result
[17:26:34.672] }
[17:26:34.676] assign_globals() ...
[17:26:34.677] List of 1
[17:26:34.677]  $ a: num 2
[17:26:34.677]  - attr(*, "where")=List of 1
[17:26:34.677]   ..$ a:<environment: R_EmptyEnv> 
[17:26:34.677]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:26:34.677]  - attr(*, "resolved")= logi FALSE
[17:26:34.677]  - attr(*, "total_size")= num 56
[17:26:34.677]  - attr(*, "already-done")= logi TRUE
[17:26:34.682] - copied 'a' to environment
[17:26:34.682] assign_globals() ... done
[17:26:34.682] plan(): Setting new future strategy stack:
[17:26:34.683] List of future strategies:
[17:26:34.683] 1. sequential:
[17:26:34.683]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:34.683]    - tweaked: FALSE
[17:26:34.683]    - call: NULL
[17:26:34.683] plan(): nbrOfWorkers() = 1
[17:26:34.684] plan(): Setting new future strategy stack:
[17:26:34.685] List of future strategies:
[17:26:34.685] 1. sequential:
[17:26:34.685]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:34.685]    - tweaked: FALSE
[17:26:34.685]    - call: plan(strategy)
[17:26:34.687] plan(): nbrOfWorkers() = 1
[17:26:34.687] SequentialFuture started (and completed)
[17:26:34.688] - Launch lazy future ... done
[17:26:34.688] run() for 'SequentialFuture' ... done
** Future evaluation with errors
[17:26:34.688] getGlobalsAndPackages() ...
[17:26:34.688] Searching for globals...
[17:26:34.692] - globals found: [3] '{', '<-', 'stop'
[17:26:34.692] Searching for globals ... DONE
[17:26:34.693] Resolving globals: FALSE
[17:26:34.693] 
[17:26:34.693] 
[17:26:34.693] getGlobalsAndPackages() ... DONE
[17:26:34.694] run() for 'Future' ...
[17:26:34.694] - state: 'created'
[17:26:34.694] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:34.694] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:34.695] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:34.695]   - Field: 'label'
[17:26:34.695]   - Field: 'local'
[17:26:34.695]   - Field: 'owner'
[17:26:34.695]   - Field: 'envir'
[17:26:34.696]   - Field: 'packages'
[17:26:34.696]   - Field: 'gc'
[17:26:34.696]   - Field: 'conditions'
[17:26:34.696]   - Field: 'expr'
[17:26:34.696]   - Field: 'uuid'
[17:26:34.696]   - Field: 'seed'
[17:26:34.697]   - Field: 'version'
[17:26:34.697]   - Field: 'result'
[17:26:34.697]   - Field: 'asynchronous'
[17:26:34.697]   - Field: 'calls'
[17:26:34.697]   - Field: 'globals'
[17:26:34.697]   - Field: 'stdout'
[17:26:34.698]   - Field: 'earlySignal'
[17:26:34.698]   - Field: 'lazy'
[17:26:34.698]   - Field: 'state'
[17:26:34.698] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:34.698] - Launch lazy future ...
[17:26:34.699] Packages needed by the future expression (n = 0): <none>
[17:26:34.699] Packages needed by future strategies (n = 0): <none>
[17:26:34.699] {
[17:26:34.699]     {
[17:26:34.699]         {
[17:26:34.699]             ...future.startTime <- base::Sys.time()
[17:26:34.699]             {
[17:26:34.699]                 {
[17:26:34.699]                   {
[17:26:34.699]                     base::local({
[17:26:34.699]                       has_future <- base::requireNamespace("future", 
[17:26:34.699]                         quietly = TRUE)
[17:26:34.699]                       if (has_future) {
[17:26:34.699]                         ns <- base::getNamespace("future")
[17:26:34.699]                         version <- ns[[".package"]][["version"]]
[17:26:34.699]                         if (is.null(version)) 
[17:26:34.699]                           version <- utils::packageVersion("future")
[17:26:34.699]                       }
[17:26:34.699]                       else {
[17:26:34.699]                         version <- NULL
[17:26:34.699]                       }
[17:26:34.699]                       if (!has_future || version < "1.8.0") {
[17:26:34.699]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:34.699]                           "", base::R.version$version.string), 
[17:26:34.699]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:34.699]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:34.699]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:34.699]                             "release", "version")], collapse = " "), 
[17:26:34.699]                           hostname = base::Sys.info()[["nodename"]])
[17:26:34.699]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:34.699]                           info)
[17:26:34.699]                         info <- base::paste(info, collapse = "; ")
[17:26:34.699]                         if (!has_future) {
[17:26:34.699]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:34.699]                             info)
[17:26:34.699]                         }
[17:26:34.699]                         else {
[17:26:34.699]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:34.699]                             info, version)
[17:26:34.699]                         }
[17:26:34.699]                         base::stop(msg)
[17:26:34.699]                       }
[17:26:34.699]                     })
[17:26:34.699]                   }
[17:26:34.699]                   ...future.strategy.old <- future::plan("list")
[17:26:34.699]                   options(future.plan = NULL)
[17:26:34.699]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:34.699]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:34.699]                 }
[17:26:34.699]                 ...future.workdir <- getwd()
[17:26:34.699]             }
[17:26:34.699]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:34.699]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:34.699]         }
[17:26:34.699]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:34.699]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:34.699]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:34.699]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:34.699]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:34.699]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:34.699]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:34.699]             base::names(...future.oldOptions))
[17:26:34.699]     }
[17:26:34.699]     if (FALSE) {
[17:26:34.699]     }
[17:26:34.699]     else {
[17:26:34.699]         if (TRUE) {
[17:26:34.699]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:34.699]                 open = "w")
[17:26:34.699]         }
[17:26:34.699]         else {
[17:26:34.699]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:34.699]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:34.699]         }
[17:26:34.699]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:34.699]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:34.699]             base::sink(type = "output", split = FALSE)
[17:26:34.699]             base::close(...future.stdout)
[17:26:34.699]         }, add = TRUE)
[17:26:34.699]     }
[17:26:34.699]     ...future.frame <- base::sys.nframe()
[17:26:34.699]     ...future.conditions <- base::list()
[17:26:34.699]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:34.699]     if (FALSE) {
[17:26:34.699]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:34.699]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:34.699]     }
[17:26:34.699]     ...future.result <- base::tryCatch({
[17:26:34.699]         base::withCallingHandlers({
[17:26:34.699]             ...future.value <- base::withVisible(base::local({
[17:26:34.699]                 x <- 3
[17:26:34.699]                 stop("Woops!")
[17:26:34.699]                 x
[17:26:34.699]             }))
[17:26:34.699]             future::FutureResult(value = ...future.value$value, 
[17:26:34.699]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:34.699]                   ...future.rng), globalenv = if (FALSE) 
[17:26:34.699]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:34.699]                     ...future.globalenv.names))
[17:26:34.699]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:34.699]         }, condition = base::local({
[17:26:34.699]             c <- base::c
[17:26:34.699]             inherits <- base::inherits
[17:26:34.699]             invokeRestart <- base::invokeRestart
[17:26:34.699]             length <- base::length
[17:26:34.699]             list <- base::list
[17:26:34.699]             seq.int <- base::seq.int
[17:26:34.699]             signalCondition <- base::signalCondition
[17:26:34.699]             sys.calls <- base::sys.calls
[17:26:34.699]             `[[` <- base::`[[`
[17:26:34.699]             `+` <- base::`+`
[17:26:34.699]             `<<-` <- base::`<<-`
[17:26:34.699]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:34.699]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:34.699]                   3L)]
[17:26:34.699]             }
[17:26:34.699]             function(cond) {
[17:26:34.699]                 is_error <- inherits(cond, "error")
[17:26:34.699]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:34.699]                   NULL)
[17:26:34.699]                 if (is_error) {
[17:26:34.699]                   sessionInformation <- function() {
[17:26:34.699]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:34.699]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:34.699]                       search = base::search(), system = base::Sys.info())
[17:26:34.699]                   }
[17:26:34.699]                   ...future.conditions[[length(...future.conditions) + 
[17:26:34.699]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:34.699]                     cond$call), session = sessionInformation(), 
[17:26:34.699]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:34.699]                   signalCondition(cond)
[17:26:34.699]                 }
[17:26:34.699]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:34.699]                 "immediateCondition"))) {
[17:26:34.699]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:34.699]                   ...future.conditions[[length(...future.conditions) + 
[17:26:34.699]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:34.699]                   if (TRUE && !signal) {
[17:26:34.699]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.699]                     {
[17:26:34.699]                       inherits <- base::inherits
[17:26:34.699]                       invokeRestart <- base::invokeRestart
[17:26:34.699]                       is.null <- base::is.null
[17:26:34.699]                       muffled <- FALSE
[17:26:34.699]                       if (inherits(cond, "message")) {
[17:26:34.699]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:34.699]                         if (muffled) 
[17:26:34.699]                           invokeRestart("muffleMessage")
[17:26:34.699]                       }
[17:26:34.699]                       else if (inherits(cond, "warning")) {
[17:26:34.699]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:34.699]                         if (muffled) 
[17:26:34.699]                           invokeRestart("muffleWarning")
[17:26:34.699]                       }
[17:26:34.699]                       else if (inherits(cond, "condition")) {
[17:26:34.699]                         if (!is.null(pattern)) {
[17:26:34.699]                           computeRestarts <- base::computeRestarts
[17:26:34.699]                           grepl <- base::grepl
[17:26:34.699]                           restarts <- computeRestarts(cond)
[17:26:34.699]                           for (restart in restarts) {
[17:26:34.699]                             name <- restart$name
[17:26:34.699]                             if (is.null(name)) 
[17:26:34.699]                               next
[17:26:34.699]                             if (!grepl(pattern, name)) 
[17:26:34.699]                               next
[17:26:34.699]                             invokeRestart(restart)
[17:26:34.699]                             muffled <- TRUE
[17:26:34.699]                             break
[17:26:34.699]                           }
[17:26:34.699]                         }
[17:26:34.699]                       }
[17:26:34.699]                       invisible(muffled)
[17:26:34.699]                     }
[17:26:34.699]                     muffleCondition(cond, pattern = "^muffle")
[17:26:34.699]                   }
[17:26:34.699]                 }
[17:26:34.699]                 else {
[17:26:34.699]                   if (TRUE) {
[17:26:34.699]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.699]                     {
[17:26:34.699]                       inherits <- base::inherits
[17:26:34.699]                       invokeRestart <- base::invokeRestart
[17:26:34.699]                       is.null <- base::is.null
[17:26:34.699]                       muffled <- FALSE
[17:26:34.699]                       if (inherits(cond, "message")) {
[17:26:34.699]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:34.699]                         if (muffled) 
[17:26:34.699]                           invokeRestart("muffleMessage")
[17:26:34.699]                       }
[17:26:34.699]                       else if (inherits(cond, "warning")) {
[17:26:34.699]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:34.699]                         if (muffled) 
[17:26:34.699]                           invokeRestart("muffleWarning")
[17:26:34.699]                       }
[17:26:34.699]                       else if (inherits(cond, "condition")) {
[17:26:34.699]                         if (!is.null(pattern)) {
[17:26:34.699]                           computeRestarts <- base::computeRestarts
[17:26:34.699]                           grepl <- base::grepl
[17:26:34.699]                           restarts <- computeRestarts(cond)
[17:26:34.699]                           for (restart in restarts) {
[17:26:34.699]                             name <- restart$name
[17:26:34.699]                             if (is.null(name)) 
[17:26:34.699]                               next
[17:26:34.699]                             if (!grepl(pattern, name)) 
[17:26:34.699]                               next
[17:26:34.699]                             invokeRestart(restart)
[17:26:34.699]                             muffled <- TRUE
[17:26:34.699]                             break
[17:26:34.699]                           }
[17:26:34.699]                         }
[17:26:34.699]                       }
[17:26:34.699]                       invisible(muffled)
[17:26:34.699]                     }
[17:26:34.699]                     muffleCondition(cond, pattern = "^muffle")
[17:26:34.699]                   }
[17:26:34.699]                 }
[17:26:34.699]             }
[17:26:34.699]         }))
[17:26:34.699]     }, error = function(ex) {
[17:26:34.699]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:34.699]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:34.699]                 ...future.rng), started = ...future.startTime, 
[17:26:34.699]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:34.699]             version = "1.8"), class = "FutureResult")
[17:26:34.699]     }, finally = {
[17:26:34.699]         if (!identical(...future.workdir, getwd())) 
[17:26:34.699]             setwd(...future.workdir)
[17:26:34.699]         {
[17:26:34.699]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:34.699]                 ...future.oldOptions$nwarnings <- NULL
[17:26:34.699]             }
[17:26:34.699]             base::options(...future.oldOptions)
[17:26:34.699]             if (.Platform$OS.type == "windows") {
[17:26:34.699]                 old_names <- names(...future.oldEnvVars)
[17:26:34.699]                 envs <- base::Sys.getenv()
[17:26:34.699]                 names <- names(envs)
[17:26:34.699]                 common <- intersect(names, old_names)
[17:26:34.699]                 added <- setdiff(names, old_names)
[17:26:34.699]                 removed <- setdiff(old_names, names)
[17:26:34.699]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:34.699]                   envs[common]]
[17:26:34.699]                 NAMES <- toupper(changed)
[17:26:34.699]                 args <- list()
[17:26:34.699]                 for (kk in seq_along(NAMES)) {
[17:26:34.699]                   name <- changed[[kk]]
[17:26:34.699]                   NAME <- NAMES[[kk]]
[17:26:34.699]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.699]                     next
[17:26:34.699]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:34.699]                 }
[17:26:34.699]                 NAMES <- toupper(added)
[17:26:34.699]                 for (kk in seq_along(NAMES)) {
[17:26:34.699]                   name <- added[[kk]]
[17:26:34.699]                   NAME <- NAMES[[kk]]
[17:26:34.699]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.699]                     next
[17:26:34.699]                   args[[name]] <- ""
[17:26:34.699]                 }
[17:26:34.699]                 NAMES <- toupper(removed)
[17:26:34.699]                 for (kk in seq_along(NAMES)) {
[17:26:34.699]                   name <- removed[[kk]]
[17:26:34.699]                   NAME <- NAMES[[kk]]
[17:26:34.699]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.699]                     next
[17:26:34.699]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:34.699]                 }
[17:26:34.699]                 if (length(args) > 0) 
[17:26:34.699]                   base::do.call(base::Sys.setenv, args = args)
[17:26:34.699]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:34.699]             }
[17:26:34.699]             else {
[17:26:34.699]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:34.699]             }
[17:26:34.699]             {
[17:26:34.699]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:34.699]                   0L) {
[17:26:34.699]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:34.699]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:34.699]                   base::options(opts)
[17:26:34.699]                 }
[17:26:34.699]                 {
[17:26:34.699]                   {
[17:26:34.699]                     NULL
[17:26:34.699]                     RNGkind("Mersenne-Twister")
[17:26:34.699]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:34.699]                       inherits = FALSE)
[17:26:34.699]                   }
[17:26:34.699]                   options(future.plan = NULL)
[17:26:34.699]                   if (is.na(NA_character_)) 
[17:26:34.699]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:34.699]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:34.699]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:34.699]                     .init = FALSE)
[17:26:34.699]                 }
[17:26:34.699]             }
[17:26:34.699]         }
[17:26:34.699]     })
[17:26:34.699]     if (TRUE) {
[17:26:34.699]         base::sink(type = "output", split = FALSE)
[17:26:34.699]         if (TRUE) {
[17:26:34.699]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:34.699]         }
[17:26:34.699]         else {
[17:26:34.699]             ...future.result["stdout"] <- base::list(NULL)
[17:26:34.699]         }
[17:26:34.699]         base::close(...future.stdout)
[17:26:34.699]         ...future.stdout <- NULL
[17:26:34.699]     }
[17:26:34.699]     ...future.result$conditions <- ...future.conditions
[17:26:34.699]     ...future.result$finished <- base::Sys.time()
[17:26:34.699]     ...future.result
[17:26:34.699] }
[17:26:34.703] plan(): Setting new future strategy stack:
[17:26:34.703] List of future strategies:
[17:26:34.703] 1. sequential:
[17:26:34.703]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:34.703]    - tweaked: FALSE
[17:26:34.703]    - call: NULL
[17:26:34.704] plan(): nbrOfWorkers() = 1
[17:26:34.705] plan(): Setting new future strategy stack:
[17:26:34.706] List of future strategies:
[17:26:34.706] 1. sequential:
[17:26:34.706]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:34.706]    - tweaked: FALSE
[17:26:34.706]    - call: plan(strategy)
[17:26:34.706] plan(): nbrOfWorkers() = 1
[17:26:34.706] SequentialFuture started (and completed)
[17:26:34.707] signalConditions() ...
[17:26:34.707]  - include = 'immediateCondition'
[17:26:34.707]  - exclude = 
[17:26:34.707]  - resignal = FALSE
[17:26:34.707]  - Number of conditions: 1
[17:26:34.707] signalConditions() ... done
[17:26:34.708] - Launch lazy future ... done
[17:26:34.708] run() for 'SequentialFuture' ... done
[17:26:34.708] signalConditions() ...
[17:26:34.708]  - include = 'immediateCondition'
[17:26:34.708]  - exclude = 
[17:26:34.709]  - resignal = FALSE
[17:26:34.709]  - Number of conditions: 1
[17:26:34.709] signalConditions() ... done
[17:26:34.709] Future state: 'finished'
[17:26:34.709] signalConditions() ...
[17:26:34.709]  - include = 'condition'
[17:26:34.710]  - exclude = 'immediateCondition'
[17:26:34.710]  - resignal = TRUE
[17:26:34.710]  - Number of conditions: 1
[17:26:34.710]  - Condition #1: 'simpleError', 'error', 'condition'
[17:26:34.710] signalConditions() ... done
[17:26:34.711] getGlobalsAndPackages() ...
[17:26:34.711] Searching for globals...
[17:26:34.713] - globals found: [6] '{', 'if', '==', '%%', 'ii', 'stop'
[17:26:34.714] Searching for globals ... DONE
[17:26:34.714] Resolving globals: FALSE
[17:26:34.714] The total size of the 1 globals is 56 bytes (56 bytes)
[17:26:34.715] The total size of the 1 globals exported for future expression ('{; if (ii%%2 == 0); stop("Woops!"); ii; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'ii' (56 bytes of class 'numeric')
[17:26:34.715] - globals: [1] 'ii'
[17:26:34.715] 
[17:26:34.715] getGlobalsAndPackages() ... DONE
[17:26:34.716] run() for 'Future' ...
[17:26:34.716] - state: 'created'
[17:26:34.716] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:34.716] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:34.717] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:34.717]   - Field: 'label'
[17:26:34.717]   - Field: 'local'
[17:26:34.717]   - Field: 'owner'
[17:26:34.717]   - Field: 'envir'
[17:26:34.717]   - Field: 'packages'
[17:26:34.718]   - Field: 'gc'
[17:26:34.718]   - Field: 'conditions'
[17:26:34.718]   - Field: 'expr'
[17:26:34.718]   - Field: 'uuid'
[17:26:34.718]   - Field: 'seed'
[17:26:34.719]   - Field: 'version'
[17:26:34.719]   - Field: 'result'
[17:26:34.720]   - Field: 'asynchronous'
[17:26:34.720]   - Field: 'calls'
[17:26:34.720]   - Field: 'globals'
[17:26:34.720]   - Field: 'stdout'
[17:26:34.720]   - Field: 'earlySignal'
[17:26:34.721]   - Field: 'lazy'
[17:26:34.721]   - Field: 'state'
[17:26:34.721] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:34.721] - Launch lazy future ...
[17:26:34.721] Packages needed by the future expression (n = 0): <none>
[17:26:34.722] Packages needed by future strategies (n = 0): <none>
[17:26:34.722] {
[17:26:34.722]     {
[17:26:34.722]         {
[17:26:34.722]             ...future.startTime <- base::Sys.time()
[17:26:34.722]             {
[17:26:34.722]                 {
[17:26:34.722]                   {
[17:26:34.722]                     base::local({
[17:26:34.722]                       has_future <- base::requireNamespace("future", 
[17:26:34.722]                         quietly = TRUE)
[17:26:34.722]                       if (has_future) {
[17:26:34.722]                         ns <- base::getNamespace("future")
[17:26:34.722]                         version <- ns[[".package"]][["version"]]
[17:26:34.722]                         if (is.null(version)) 
[17:26:34.722]                           version <- utils::packageVersion("future")
[17:26:34.722]                       }
[17:26:34.722]                       else {
[17:26:34.722]                         version <- NULL
[17:26:34.722]                       }
[17:26:34.722]                       if (!has_future || version < "1.8.0") {
[17:26:34.722]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:34.722]                           "", base::R.version$version.string), 
[17:26:34.722]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:34.722]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:34.722]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:34.722]                             "release", "version")], collapse = " "), 
[17:26:34.722]                           hostname = base::Sys.info()[["nodename"]])
[17:26:34.722]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:34.722]                           info)
[17:26:34.722]                         info <- base::paste(info, collapse = "; ")
[17:26:34.722]                         if (!has_future) {
[17:26:34.722]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:34.722]                             info)
[17:26:34.722]                         }
[17:26:34.722]                         else {
[17:26:34.722]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:34.722]                             info, version)
[17:26:34.722]                         }
[17:26:34.722]                         base::stop(msg)
[17:26:34.722]                       }
[17:26:34.722]                     })
[17:26:34.722]                   }
[17:26:34.722]                   ...future.strategy.old <- future::plan("list")
[17:26:34.722]                   options(future.plan = NULL)
[17:26:34.722]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:34.722]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:34.722]                 }
[17:26:34.722]                 ...future.workdir <- getwd()
[17:26:34.722]             }
[17:26:34.722]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:34.722]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:34.722]         }
[17:26:34.722]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:34.722]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:34.722]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:34.722]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:34.722]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:34.722]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:34.722]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:34.722]             base::names(...future.oldOptions))
[17:26:34.722]     }
[17:26:34.722]     if (FALSE) {
[17:26:34.722]     }
[17:26:34.722]     else {
[17:26:34.722]         if (TRUE) {
[17:26:34.722]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:34.722]                 open = "w")
[17:26:34.722]         }
[17:26:34.722]         else {
[17:26:34.722]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:34.722]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:34.722]         }
[17:26:34.722]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:34.722]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:34.722]             base::sink(type = "output", split = FALSE)
[17:26:34.722]             base::close(...future.stdout)
[17:26:34.722]         }, add = TRUE)
[17:26:34.722]     }
[17:26:34.722]     ...future.frame <- base::sys.nframe()
[17:26:34.722]     ...future.conditions <- base::list()
[17:26:34.722]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:34.722]     if (FALSE) {
[17:26:34.722]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:34.722]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:34.722]     }
[17:26:34.722]     ...future.result <- base::tryCatch({
[17:26:34.722]         base::withCallingHandlers({
[17:26:34.722]             ...future.value <- base::withVisible(base::local({
[17:26:34.722]                 if (ii%%2 == 0) 
[17:26:34.722]                   stop("Woops!")
[17:26:34.722]                 ii
[17:26:34.722]             }))
[17:26:34.722]             future::FutureResult(value = ...future.value$value, 
[17:26:34.722]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:34.722]                   ...future.rng), globalenv = if (FALSE) 
[17:26:34.722]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:34.722]                     ...future.globalenv.names))
[17:26:34.722]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:34.722]         }, condition = base::local({
[17:26:34.722]             c <- base::c
[17:26:34.722]             inherits <- base::inherits
[17:26:34.722]             invokeRestart <- base::invokeRestart
[17:26:34.722]             length <- base::length
[17:26:34.722]             list <- base::list
[17:26:34.722]             seq.int <- base::seq.int
[17:26:34.722]             signalCondition <- base::signalCondition
[17:26:34.722]             sys.calls <- base::sys.calls
[17:26:34.722]             `[[` <- base::`[[`
[17:26:34.722]             `+` <- base::`+`
[17:26:34.722]             `<<-` <- base::`<<-`
[17:26:34.722]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:34.722]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:34.722]                   3L)]
[17:26:34.722]             }
[17:26:34.722]             function(cond) {
[17:26:34.722]                 is_error <- inherits(cond, "error")
[17:26:34.722]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:34.722]                   NULL)
[17:26:34.722]                 if (is_error) {
[17:26:34.722]                   sessionInformation <- function() {
[17:26:34.722]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:34.722]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:34.722]                       search = base::search(), system = base::Sys.info())
[17:26:34.722]                   }
[17:26:34.722]                   ...future.conditions[[length(...future.conditions) + 
[17:26:34.722]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:34.722]                     cond$call), session = sessionInformation(), 
[17:26:34.722]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:34.722]                   signalCondition(cond)
[17:26:34.722]                 }
[17:26:34.722]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:34.722]                 "immediateCondition"))) {
[17:26:34.722]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:34.722]                   ...future.conditions[[length(...future.conditions) + 
[17:26:34.722]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:34.722]                   if (TRUE && !signal) {
[17:26:34.722]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.722]                     {
[17:26:34.722]                       inherits <- base::inherits
[17:26:34.722]                       invokeRestart <- base::invokeRestart
[17:26:34.722]                       is.null <- base::is.null
[17:26:34.722]                       muffled <- FALSE
[17:26:34.722]                       if (inherits(cond, "message")) {
[17:26:34.722]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:34.722]                         if (muffled) 
[17:26:34.722]                           invokeRestart("muffleMessage")
[17:26:34.722]                       }
[17:26:34.722]                       else if (inherits(cond, "warning")) {
[17:26:34.722]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:34.722]                         if (muffled) 
[17:26:34.722]                           invokeRestart("muffleWarning")
[17:26:34.722]                       }
[17:26:34.722]                       else if (inherits(cond, "condition")) {
[17:26:34.722]                         if (!is.null(pattern)) {
[17:26:34.722]                           computeRestarts <- base::computeRestarts
[17:26:34.722]                           grepl <- base::grepl
[17:26:34.722]                           restarts <- computeRestarts(cond)
[17:26:34.722]                           for (restart in restarts) {
[17:26:34.722]                             name <- restart$name
[17:26:34.722]                             if (is.null(name)) 
[17:26:34.722]                               next
[17:26:34.722]                             if (!grepl(pattern, name)) 
[17:26:34.722]                               next
[17:26:34.722]                             invokeRestart(restart)
[17:26:34.722]                             muffled <- TRUE
[17:26:34.722]                             break
[17:26:34.722]                           }
[17:26:34.722]                         }
[17:26:34.722]                       }
[17:26:34.722]                       invisible(muffled)
[17:26:34.722]                     }
[17:26:34.722]                     muffleCondition(cond, pattern = "^muffle")
[17:26:34.722]                   }
[17:26:34.722]                 }
[17:26:34.722]                 else {
[17:26:34.722]                   if (TRUE) {
[17:26:34.722]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.722]                     {
[17:26:34.722]                       inherits <- base::inherits
[17:26:34.722]                       invokeRestart <- base::invokeRestart
[17:26:34.722]                       is.null <- base::is.null
[17:26:34.722]                       muffled <- FALSE
[17:26:34.722]                       if (inherits(cond, "message")) {
[17:26:34.722]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:34.722]                         if (muffled) 
[17:26:34.722]                           invokeRestart("muffleMessage")
[17:26:34.722]                       }
[17:26:34.722]                       else if (inherits(cond, "warning")) {
[17:26:34.722]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:34.722]                         if (muffled) 
[17:26:34.722]                           invokeRestart("muffleWarning")
[17:26:34.722]                       }
[17:26:34.722]                       else if (inherits(cond, "condition")) {
[17:26:34.722]                         if (!is.null(pattern)) {
[17:26:34.722]                           computeRestarts <- base::computeRestarts
[17:26:34.722]                           grepl <- base::grepl
[17:26:34.722]                           restarts <- computeRestarts(cond)
[17:26:34.722]                           for (restart in restarts) {
[17:26:34.722]                             name <- restart$name
[17:26:34.722]                             if (is.null(name)) 
[17:26:34.722]                               next
[17:26:34.722]                             if (!grepl(pattern, name)) 
[17:26:34.722]                               next
[17:26:34.722]                             invokeRestart(restart)
[17:26:34.722]                             muffled <- TRUE
[17:26:34.722]                             break
[17:26:34.722]                           }
[17:26:34.722]                         }
[17:26:34.722]                       }
[17:26:34.722]                       invisible(muffled)
[17:26:34.722]                     }
[17:26:34.722]                     muffleCondition(cond, pattern = "^muffle")
[17:26:34.722]                   }
[17:26:34.722]                 }
[17:26:34.722]             }
[17:26:34.722]         }))
[17:26:34.722]     }, error = function(ex) {
[17:26:34.722]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:34.722]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:34.722]                 ...future.rng), started = ...future.startTime, 
[17:26:34.722]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:34.722]             version = "1.8"), class = "FutureResult")
[17:26:34.722]     }, finally = {
[17:26:34.722]         if (!identical(...future.workdir, getwd())) 
[17:26:34.722]             setwd(...future.workdir)
[17:26:34.722]         {
[17:26:34.722]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:34.722]                 ...future.oldOptions$nwarnings <- NULL
[17:26:34.722]             }
[17:26:34.722]             base::options(...future.oldOptions)
[17:26:34.722]             if (.Platform$OS.type == "windows") {
[17:26:34.722]                 old_names <- names(...future.oldEnvVars)
[17:26:34.722]                 envs <- base::Sys.getenv()
[17:26:34.722]                 names <- names(envs)
[17:26:34.722]                 common <- intersect(names, old_names)
[17:26:34.722]                 added <- setdiff(names, old_names)
[17:26:34.722]                 removed <- setdiff(old_names, names)
[17:26:34.722]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:34.722]                   envs[common]]
[17:26:34.722]                 NAMES <- toupper(changed)
[17:26:34.722]                 args <- list()
[17:26:34.722]                 for (kk in seq_along(NAMES)) {
[17:26:34.722]                   name <- changed[[kk]]
[17:26:34.722]                   NAME <- NAMES[[kk]]
[17:26:34.722]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.722]                     next
[17:26:34.722]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:34.722]                 }
[17:26:34.722]                 NAMES <- toupper(added)
[17:26:34.722]                 for (kk in seq_along(NAMES)) {
[17:26:34.722]                   name <- added[[kk]]
[17:26:34.722]                   NAME <- NAMES[[kk]]
[17:26:34.722]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.722]                     next
[17:26:34.722]                   args[[name]] <- ""
[17:26:34.722]                 }
[17:26:34.722]                 NAMES <- toupper(removed)
[17:26:34.722]                 for (kk in seq_along(NAMES)) {
[17:26:34.722]                   name <- removed[[kk]]
[17:26:34.722]                   NAME <- NAMES[[kk]]
[17:26:34.722]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.722]                     next
[17:26:34.722]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:34.722]                 }
[17:26:34.722]                 if (length(args) > 0) 
[17:26:34.722]                   base::do.call(base::Sys.setenv, args = args)
[17:26:34.722]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:34.722]             }
[17:26:34.722]             else {
[17:26:34.722]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:34.722]             }
[17:26:34.722]             {
[17:26:34.722]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:34.722]                   0L) {
[17:26:34.722]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:34.722]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:34.722]                   base::options(opts)
[17:26:34.722]                 }
[17:26:34.722]                 {
[17:26:34.722]                   {
[17:26:34.722]                     NULL
[17:26:34.722]                     RNGkind("Mersenne-Twister")
[17:26:34.722]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:34.722]                       inherits = FALSE)
[17:26:34.722]                   }
[17:26:34.722]                   options(future.plan = NULL)
[17:26:34.722]                   if (is.na(NA_character_)) 
[17:26:34.722]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:34.722]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:34.722]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:34.722]                     .init = FALSE)
[17:26:34.722]                 }
[17:26:34.722]             }
[17:26:34.722]         }
[17:26:34.722]     })
[17:26:34.722]     if (TRUE) {
[17:26:34.722]         base::sink(type = "output", split = FALSE)
[17:26:34.722]         if (TRUE) {
[17:26:34.722]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:34.722]         }
[17:26:34.722]         else {
[17:26:34.722]             ...future.result["stdout"] <- base::list(NULL)
[17:26:34.722]         }
[17:26:34.722]         base::close(...future.stdout)
[17:26:34.722]         ...future.stdout <- NULL
[17:26:34.722]     }
[17:26:34.722]     ...future.result$conditions <- ...future.conditions
[17:26:34.722]     ...future.result$finished <- base::Sys.time()
[17:26:34.722]     ...future.result
[17:26:34.722] }
[17:26:34.726] assign_globals() ...
[17:26:34.726] List of 1
[17:26:34.726]  $ ii: int 1
[17:26:34.726]  - attr(*, "where")=List of 1
[17:26:34.726]   ..$ ii:<environment: R_EmptyEnv> 
[17:26:34.726]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:26:34.726]  - attr(*, "resolved")= logi FALSE
[17:26:34.726]  - attr(*, "total_size")= num 56
[17:26:34.726]  - attr(*, "already-done")= logi TRUE
[17:26:34.729] - copied 'ii' to environment
[17:26:34.729] assign_globals() ... done
[17:26:34.729] plan(): Setting new future strategy stack:
[17:26:34.730] List of future strategies:
[17:26:34.730] 1. sequential:
[17:26:34.730]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:34.730]    - tweaked: FALSE
[17:26:34.730]    - call: NULL
[17:26:34.730] plan(): nbrOfWorkers() = 1
[17:26:34.731] plan(): Setting new future strategy stack:
[17:26:34.731] List of future strategies:
[17:26:34.731] 1. sequential:
[17:26:34.731]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:34.731]    - tweaked: FALSE
[17:26:34.731]    - call: plan(strategy)
[17:26:34.732] plan(): nbrOfWorkers() = 1
[17:26:34.732] SequentialFuture started (and completed)
[17:26:34.732] - Launch lazy future ... done
[17:26:34.733] run() for 'SequentialFuture' ... done
[17:26:34.733] getGlobalsAndPackages() ...
[17:26:34.733] Searching for globals...
[17:26:34.735] - globals found: [6] '{', 'if', '==', '%%', 'ii', 'stop'
[17:26:34.735] Searching for globals ... DONE
[17:26:34.735] Resolving globals: FALSE
[17:26:34.736] The total size of the 1 globals is 56 bytes (56 bytes)
[17:26:34.736] The total size of the 1 globals exported for future expression ('{; if (ii%%2 == 0); stop("Woops!"); ii; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'ii' (56 bytes of class 'numeric')
[17:26:34.737] - globals: [1] 'ii'
[17:26:34.737] 
[17:26:34.737] getGlobalsAndPackages() ... DONE
[17:26:34.737] run() for 'Future' ...
[17:26:34.737] - state: 'created'
[17:26:34.738] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:34.738] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:34.738] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:34.738]   - Field: 'label'
[17:26:34.739]   - Field: 'local'
[17:26:34.739]   - Field: 'owner'
[17:26:34.739]   - Field: 'envir'
[17:26:34.739]   - Field: 'packages'
[17:26:34.739]   - Field: 'gc'
[17:26:34.739]   - Field: 'conditions'
[17:26:34.740]   - Field: 'expr'
[17:26:34.740]   - Field: 'uuid'
[17:26:34.740]   - Field: 'seed'
[17:26:34.740]   - Field: 'version'
[17:26:34.740]   - Field: 'result'
[17:26:34.740]   - Field: 'asynchronous'
[17:26:34.741]   - Field: 'calls'
[17:26:34.741]   - Field: 'globals'
[17:26:34.741]   - Field: 'stdout'
[17:26:34.741]   - Field: 'earlySignal'
[17:26:34.741]   - Field: 'lazy'
[17:26:34.741]   - Field: 'state'
[17:26:34.742] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:34.742] - Launch lazy future ...
[17:26:34.742] Packages needed by the future expression (n = 0): <none>
[17:26:34.742] Packages needed by future strategies (n = 0): <none>
[17:26:34.743] {
[17:26:34.743]     {
[17:26:34.743]         {
[17:26:34.743]             ...future.startTime <- base::Sys.time()
[17:26:34.743]             {
[17:26:34.743]                 {
[17:26:34.743]                   {
[17:26:34.743]                     base::local({
[17:26:34.743]                       has_future <- base::requireNamespace("future", 
[17:26:34.743]                         quietly = TRUE)
[17:26:34.743]                       if (has_future) {
[17:26:34.743]                         ns <- base::getNamespace("future")
[17:26:34.743]                         version <- ns[[".package"]][["version"]]
[17:26:34.743]                         if (is.null(version)) 
[17:26:34.743]                           version <- utils::packageVersion("future")
[17:26:34.743]                       }
[17:26:34.743]                       else {
[17:26:34.743]                         version <- NULL
[17:26:34.743]                       }
[17:26:34.743]                       if (!has_future || version < "1.8.0") {
[17:26:34.743]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:34.743]                           "", base::R.version$version.string), 
[17:26:34.743]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:34.743]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:34.743]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:34.743]                             "release", "version")], collapse = " "), 
[17:26:34.743]                           hostname = base::Sys.info()[["nodename"]])
[17:26:34.743]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:34.743]                           info)
[17:26:34.743]                         info <- base::paste(info, collapse = "; ")
[17:26:34.743]                         if (!has_future) {
[17:26:34.743]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:34.743]                             info)
[17:26:34.743]                         }
[17:26:34.743]                         else {
[17:26:34.743]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:34.743]                             info, version)
[17:26:34.743]                         }
[17:26:34.743]                         base::stop(msg)
[17:26:34.743]                       }
[17:26:34.743]                     })
[17:26:34.743]                   }
[17:26:34.743]                   ...future.strategy.old <- future::plan("list")
[17:26:34.743]                   options(future.plan = NULL)
[17:26:34.743]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:34.743]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:34.743]                 }
[17:26:34.743]                 ...future.workdir <- getwd()
[17:26:34.743]             }
[17:26:34.743]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:34.743]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:34.743]         }
[17:26:34.743]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:34.743]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:34.743]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:34.743]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:34.743]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:34.743]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:34.743]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:34.743]             base::names(...future.oldOptions))
[17:26:34.743]     }
[17:26:34.743]     if (FALSE) {
[17:26:34.743]     }
[17:26:34.743]     else {
[17:26:34.743]         if (TRUE) {
[17:26:34.743]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:34.743]                 open = "w")
[17:26:34.743]         }
[17:26:34.743]         else {
[17:26:34.743]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:34.743]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:34.743]         }
[17:26:34.743]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:34.743]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:34.743]             base::sink(type = "output", split = FALSE)
[17:26:34.743]             base::close(...future.stdout)
[17:26:34.743]         }, add = TRUE)
[17:26:34.743]     }
[17:26:34.743]     ...future.frame <- base::sys.nframe()
[17:26:34.743]     ...future.conditions <- base::list()
[17:26:34.743]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:34.743]     if (FALSE) {
[17:26:34.743]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:34.743]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:34.743]     }
[17:26:34.743]     ...future.result <- base::tryCatch({
[17:26:34.743]         base::withCallingHandlers({
[17:26:34.743]             ...future.value <- base::withVisible(base::local({
[17:26:34.743]                 if (ii%%2 == 0) 
[17:26:34.743]                   stop("Woops!")
[17:26:34.743]                 ii
[17:26:34.743]             }))
[17:26:34.743]             future::FutureResult(value = ...future.value$value, 
[17:26:34.743]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:34.743]                   ...future.rng), globalenv = if (FALSE) 
[17:26:34.743]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:34.743]                     ...future.globalenv.names))
[17:26:34.743]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:34.743]         }, condition = base::local({
[17:26:34.743]             c <- base::c
[17:26:34.743]             inherits <- base::inherits
[17:26:34.743]             invokeRestart <- base::invokeRestart
[17:26:34.743]             length <- base::length
[17:26:34.743]             list <- base::list
[17:26:34.743]             seq.int <- base::seq.int
[17:26:34.743]             signalCondition <- base::signalCondition
[17:26:34.743]             sys.calls <- base::sys.calls
[17:26:34.743]             `[[` <- base::`[[`
[17:26:34.743]             `+` <- base::`+`
[17:26:34.743]             `<<-` <- base::`<<-`
[17:26:34.743]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:34.743]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:34.743]                   3L)]
[17:26:34.743]             }
[17:26:34.743]             function(cond) {
[17:26:34.743]                 is_error <- inherits(cond, "error")
[17:26:34.743]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:34.743]                   NULL)
[17:26:34.743]                 if (is_error) {
[17:26:34.743]                   sessionInformation <- function() {
[17:26:34.743]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:34.743]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:34.743]                       search = base::search(), system = base::Sys.info())
[17:26:34.743]                   }
[17:26:34.743]                   ...future.conditions[[length(...future.conditions) + 
[17:26:34.743]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:34.743]                     cond$call), session = sessionInformation(), 
[17:26:34.743]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:34.743]                   signalCondition(cond)
[17:26:34.743]                 }
[17:26:34.743]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:34.743]                 "immediateCondition"))) {
[17:26:34.743]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:34.743]                   ...future.conditions[[length(...future.conditions) + 
[17:26:34.743]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:34.743]                   if (TRUE && !signal) {
[17:26:34.743]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.743]                     {
[17:26:34.743]                       inherits <- base::inherits
[17:26:34.743]                       invokeRestart <- base::invokeRestart
[17:26:34.743]                       is.null <- base::is.null
[17:26:34.743]                       muffled <- FALSE
[17:26:34.743]                       if (inherits(cond, "message")) {
[17:26:34.743]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:34.743]                         if (muffled) 
[17:26:34.743]                           invokeRestart("muffleMessage")
[17:26:34.743]                       }
[17:26:34.743]                       else if (inherits(cond, "warning")) {
[17:26:34.743]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:34.743]                         if (muffled) 
[17:26:34.743]                           invokeRestart("muffleWarning")
[17:26:34.743]                       }
[17:26:34.743]                       else if (inherits(cond, "condition")) {
[17:26:34.743]                         if (!is.null(pattern)) {
[17:26:34.743]                           computeRestarts <- base::computeRestarts
[17:26:34.743]                           grepl <- base::grepl
[17:26:34.743]                           restarts <- computeRestarts(cond)
[17:26:34.743]                           for (restart in restarts) {
[17:26:34.743]                             name <- restart$name
[17:26:34.743]                             if (is.null(name)) 
[17:26:34.743]                               next
[17:26:34.743]                             if (!grepl(pattern, name)) 
[17:26:34.743]                               next
[17:26:34.743]                             invokeRestart(restart)
[17:26:34.743]                             muffled <- TRUE
[17:26:34.743]                             break
[17:26:34.743]                           }
[17:26:34.743]                         }
[17:26:34.743]                       }
[17:26:34.743]                       invisible(muffled)
[17:26:34.743]                     }
[17:26:34.743]                     muffleCondition(cond, pattern = "^muffle")
[17:26:34.743]                   }
[17:26:34.743]                 }
[17:26:34.743]                 else {
[17:26:34.743]                   if (TRUE) {
[17:26:34.743]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.743]                     {
[17:26:34.743]                       inherits <- base::inherits
[17:26:34.743]                       invokeRestart <- base::invokeRestart
[17:26:34.743]                       is.null <- base::is.null
[17:26:34.743]                       muffled <- FALSE
[17:26:34.743]                       if (inherits(cond, "message")) {
[17:26:34.743]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:34.743]                         if (muffled) 
[17:26:34.743]                           invokeRestart("muffleMessage")
[17:26:34.743]                       }
[17:26:34.743]                       else if (inherits(cond, "warning")) {
[17:26:34.743]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:34.743]                         if (muffled) 
[17:26:34.743]                           invokeRestart("muffleWarning")
[17:26:34.743]                       }
[17:26:34.743]                       else if (inherits(cond, "condition")) {
[17:26:34.743]                         if (!is.null(pattern)) {
[17:26:34.743]                           computeRestarts <- base::computeRestarts
[17:26:34.743]                           grepl <- base::grepl
[17:26:34.743]                           restarts <- computeRestarts(cond)
[17:26:34.743]                           for (restart in restarts) {
[17:26:34.743]                             name <- restart$name
[17:26:34.743]                             if (is.null(name)) 
[17:26:34.743]                               next
[17:26:34.743]                             if (!grepl(pattern, name)) 
[17:26:34.743]                               next
[17:26:34.743]                             invokeRestart(restart)
[17:26:34.743]                             muffled <- TRUE
[17:26:34.743]                             break
[17:26:34.743]                           }
[17:26:34.743]                         }
[17:26:34.743]                       }
[17:26:34.743]                       invisible(muffled)
[17:26:34.743]                     }
[17:26:34.743]                     muffleCondition(cond, pattern = "^muffle")
[17:26:34.743]                   }
[17:26:34.743]                 }
[17:26:34.743]             }
[17:26:34.743]         }))
[17:26:34.743]     }, error = function(ex) {
[17:26:34.743]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:34.743]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:34.743]                 ...future.rng), started = ...future.startTime, 
[17:26:34.743]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:34.743]             version = "1.8"), class = "FutureResult")
[17:26:34.743]     }, finally = {
[17:26:34.743]         if (!identical(...future.workdir, getwd())) 
[17:26:34.743]             setwd(...future.workdir)
[17:26:34.743]         {
[17:26:34.743]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:34.743]                 ...future.oldOptions$nwarnings <- NULL
[17:26:34.743]             }
[17:26:34.743]             base::options(...future.oldOptions)
[17:26:34.743]             if (.Platform$OS.type == "windows") {
[17:26:34.743]                 old_names <- names(...future.oldEnvVars)
[17:26:34.743]                 envs <- base::Sys.getenv()
[17:26:34.743]                 names <- names(envs)
[17:26:34.743]                 common <- intersect(names, old_names)
[17:26:34.743]                 added <- setdiff(names, old_names)
[17:26:34.743]                 removed <- setdiff(old_names, names)
[17:26:34.743]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:34.743]                   envs[common]]
[17:26:34.743]                 NAMES <- toupper(changed)
[17:26:34.743]                 args <- list()
[17:26:34.743]                 for (kk in seq_along(NAMES)) {
[17:26:34.743]                   name <- changed[[kk]]
[17:26:34.743]                   NAME <- NAMES[[kk]]
[17:26:34.743]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.743]                     next
[17:26:34.743]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:34.743]                 }
[17:26:34.743]                 NAMES <- toupper(added)
[17:26:34.743]                 for (kk in seq_along(NAMES)) {
[17:26:34.743]                   name <- added[[kk]]
[17:26:34.743]                   NAME <- NAMES[[kk]]
[17:26:34.743]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.743]                     next
[17:26:34.743]                   args[[name]] <- ""
[17:26:34.743]                 }
[17:26:34.743]                 NAMES <- toupper(removed)
[17:26:34.743]                 for (kk in seq_along(NAMES)) {
[17:26:34.743]                   name <- removed[[kk]]
[17:26:34.743]                   NAME <- NAMES[[kk]]
[17:26:34.743]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.743]                     next
[17:26:34.743]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:34.743]                 }
[17:26:34.743]                 if (length(args) > 0) 
[17:26:34.743]                   base::do.call(base::Sys.setenv, args = args)
[17:26:34.743]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:34.743]             }
[17:26:34.743]             else {
[17:26:34.743]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:34.743]             }
[17:26:34.743]             {
[17:26:34.743]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:34.743]                   0L) {
[17:26:34.743]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:34.743]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:34.743]                   base::options(opts)
[17:26:34.743]                 }
[17:26:34.743]                 {
[17:26:34.743]                   {
[17:26:34.743]                     NULL
[17:26:34.743]                     RNGkind("Mersenne-Twister")
[17:26:34.743]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:34.743]                       inherits = FALSE)
[17:26:34.743]                   }
[17:26:34.743]                   options(future.plan = NULL)
[17:26:34.743]                   if (is.na(NA_character_)) 
[17:26:34.743]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:34.743]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:34.743]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:34.743]                     .init = FALSE)
[17:26:34.743]                 }
[17:26:34.743]             }
[17:26:34.743]         }
[17:26:34.743]     })
[17:26:34.743]     if (TRUE) {
[17:26:34.743]         base::sink(type = "output", split = FALSE)
[17:26:34.743]         if (TRUE) {
[17:26:34.743]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:34.743]         }
[17:26:34.743]         else {
[17:26:34.743]             ...future.result["stdout"] <- base::list(NULL)
[17:26:34.743]         }
[17:26:34.743]         base::close(...future.stdout)
[17:26:34.743]         ...future.stdout <- NULL
[17:26:34.743]     }
[17:26:34.743]     ...future.result$conditions <- ...future.conditions
[17:26:34.743]     ...future.result$finished <- base::Sys.time()
[17:26:34.743]     ...future.result
[17:26:34.743] }
[17:26:34.746] assign_globals() ...
[17:26:34.747] List of 1
[17:26:34.747]  $ ii: int 2
[17:26:34.747]  - attr(*, "where")=List of 1
[17:26:34.747]   ..$ ii:<environment: R_EmptyEnv> 
[17:26:34.747]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:26:34.747]  - attr(*, "resolved")= logi FALSE
[17:26:34.747]  - attr(*, "total_size")= num 56
[17:26:34.747]  - attr(*, "already-done")= logi TRUE
[17:26:34.750] - copied 'ii' to environment
[17:26:34.750] assign_globals() ... done
[17:26:34.750] plan(): Setting new future strategy stack:
[17:26:34.750] List of future strategies:
[17:26:34.750] 1. sequential:
[17:26:34.750]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:34.750]    - tweaked: FALSE
[17:26:34.750]    - call: NULL
[17:26:34.751] plan(): nbrOfWorkers() = 1
[17:26:34.752] plan(): Setting new future strategy stack:
[17:26:34.752] List of future strategies:
[17:26:34.752] 1. sequential:
[17:26:34.752]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:34.752]    - tweaked: FALSE
[17:26:34.752]    - call: plan(strategy)
[17:26:34.753] plan(): nbrOfWorkers() = 1
[17:26:34.753] SequentialFuture started (and completed)
[17:26:34.753] signalConditions() ...
[17:26:34.754]  - include = 'immediateCondition'
[17:26:34.754]  - exclude = 
[17:26:34.755]  - resignal = FALSE
[17:26:34.755]  - Number of conditions: 1
[17:26:34.755] signalConditions() ... done
[17:26:34.755] - Launch lazy future ... done
[17:26:34.755] run() for 'SequentialFuture' ... done
[17:26:34.756] getGlobalsAndPackages() ...
[17:26:34.756] Searching for globals...
[17:26:34.758] - globals found: [6] '{', 'if', '==', '%%', 'ii', 'stop'
[17:26:34.758] Searching for globals ... DONE
[17:26:34.758] Resolving globals: FALSE
[17:26:34.759] The total size of the 1 globals is 56 bytes (56 bytes)
[17:26:34.759] The total size of the 1 globals exported for future expression ('{; if (ii%%2 == 0); stop("Woops!"); ii; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'ii' (56 bytes of class 'numeric')
[17:26:34.759] - globals: [1] 'ii'
[17:26:34.760] 
[17:26:34.760] getGlobalsAndPackages() ... DONE
[17:26:34.760] run() for 'Future' ...
[17:26:34.760] - state: 'created'
[17:26:34.760] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:34.761] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:34.761] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:34.761]   - Field: 'label'
[17:26:34.761]   - Field: 'local'
[17:26:34.761]   - Field: 'owner'
[17:26:34.762]   - Field: 'envir'
[17:26:34.762]   - Field: 'packages'
[17:26:34.762]   - Field: 'gc'
[17:26:34.762]   - Field: 'conditions'
[17:26:34.762]   - Field: 'expr'
[17:26:34.763]   - Field: 'uuid'
[17:26:34.763]   - Field: 'seed'
[17:26:34.763]   - Field: 'version'
[17:26:34.763]   - Field: 'result'
[17:26:34.763]   - Field: 'asynchronous'
[17:26:34.763]   - Field: 'calls'
[17:26:34.764]   - Field: 'globals'
[17:26:34.764]   - Field: 'stdout'
[17:26:34.764]   - Field: 'earlySignal'
[17:26:34.764]   - Field: 'lazy'
[17:26:34.764]   - Field: 'state'
[17:26:34.764] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:34.765] - Launch lazy future ...
[17:26:34.765] Packages needed by the future expression (n = 0): <none>
[17:26:34.765] Packages needed by future strategies (n = 0): <none>
[17:26:34.766] {
[17:26:34.766]     {
[17:26:34.766]         {
[17:26:34.766]             ...future.startTime <- base::Sys.time()
[17:26:34.766]             {
[17:26:34.766]                 {
[17:26:34.766]                   {
[17:26:34.766]                     base::local({
[17:26:34.766]                       has_future <- base::requireNamespace("future", 
[17:26:34.766]                         quietly = TRUE)
[17:26:34.766]                       if (has_future) {
[17:26:34.766]                         ns <- base::getNamespace("future")
[17:26:34.766]                         version <- ns[[".package"]][["version"]]
[17:26:34.766]                         if (is.null(version)) 
[17:26:34.766]                           version <- utils::packageVersion("future")
[17:26:34.766]                       }
[17:26:34.766]                       else {
[17:26:34.766]                         version <- NULL
[17:26:34.766]                       }
[17:26:34.766]                       if (!has_future || version < "1.8.0") {
[17:26:34.766]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:34.766]                           "", base::R.version$version.string), 
[17:26:34.766]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:34.766]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:34.766]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:34.766]                             "release", "version")], collapse = " "), 
[17:26:34.766]                           hostname = base::Sys.info()[["nodename"]])
[17:26:34.766]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:34.766]                           info)
[17:26:34.766]                         info <- base::paste(info, collapse = "; ")
[17:26:34.766]                         if (!has_future) {
[17:26:34.766]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:34.766]                             info)
[17:26:34.766]                         }
[17:26:34.766]                         else {
[17:26:34.766]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:34.766]                             info, version)
[17:26:34.766]                         }
[17:26:34.766]                         base::stop(msg)
[17:26:34.766]                       }
[17:26:34.766]                     })
[17:26:34.766]                   }
[17:26:34.766]                   ...future.strategy.old <- future::plan("list")
[17:26:34.766]                   options(future.plan = NULL)
[17:26:34.766]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:34.766]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:34.766]                 }
[17:26:34.766]                 ...future.workdir <- getwd()
[17:26:34.766]             }
[17:26:34.766]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:34.766]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:34.766]         }
[17:26:34.766]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:34.766]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:34.766]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:34.766]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:34.766]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:34.766]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:34.766]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:34.766]             base::names(...future.oldOptions))
[17:26:34.766]     }
[17:26:34.766]     if (FALSE) {
[17:26:34.766]     }
[17:26:34.766]     else {
[17:26:34.766]         if (TRUE) {
[17:26:34.766]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:34.766]                 open = "w")
[17:26:34.766]         }
[17:26:34.766]         else {
[17:26:34.766]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:34.766]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:34.766]         }
[17:26:34.766]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:34.766]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:34.766]             base::sink(type = "output", split = FALSE)
[17:26:34.766]             base::close(...future.stdout)
[17:26:34.766]         }, add = TRUE)
[17:26:34.766]     }
[17:26:34.766]     ...future.frame <- base::sys.nframe()
[17:26:34.766]     ...future.conditions <- base::list()
[17:26:34.766]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:34.766]     if (FALSE) {
[17:26:34.766]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:34.766]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:34.766]     }
[17:26:34.766]     ...future.result <- base::tryCatch({
[17:26:34.766]         base::withCallingHandlers({
[17:26:34.766]             ...future.value <- base::withVisible(base::local({
[17:26:34.766]                 if (ii%%2 == 0) 
[17:26:34.766]                   stop("Woops!")
[17:26:34.766]                 ii
[17:26:34.766]             }))
[17:26:34.766]             future::FutureResult(value = ...future.value$value, 
[17:26:34.766]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:34.766]                   ...future.rng), globalenv = if (FALSE) 
[17:26:34.766]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:34.766]                     ...future.globalenv.names))
[17:26:34.766]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:34.766]         }, condition = base::local({
[17:26:34.766]             c <- base::c
[17:26:34.766]             inherits <- base::inherits
[17:26:34.766]             invokeRestart <- base::invokeRestart
[17:26:34.766]             length <- base::length
[17:26:34.766]             list <- base::list
[17:26:34.766]             seq.int <- base::seq.int
[17:26:34.766]             signalCondition <- base::signalCondition
[17:26:34.766]             sys.calls <- base::sys.calls
[17:26:34.766]             `[[` <- base::`[[`
[17:26:34.766]             `+` <- base::`+`
[17:26:34.766]             `<<-` <- base::`<<-`
[17:26:34.766]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:34.766]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:34.766]                   3L)]
[17:26:34.766]             }
[17:26:34.766]             function(cond) {
[17:26:34.766]                 is_error <- inherits(cond, "error")
[17:26:34.766]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:34.766]                   NULL)
[17:26:34.766]                 if (is_error) {
[17:26:34.766]                   sessionInformation <- function() {
[17:26:34.766]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:34.766]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:34.766]                       search = base::search(), system = base::Sys.info())
[17:26:34.766]                   }
[17:26:34.766]                   ...future.conditions[[length(...future.conditions) + 
[17:26:34.766]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:34.766]                     cond$call), session = sessionInformation(), 
[17:26:34.766]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:34.766]                   signalCondition(cond)
[17:26:34.766]                 }
[17:26:34.766]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:34.766]                 "immediateCondition"))) {
[17:26:34.766]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:34.766]                   ...future.conditions[[length(...future.conditions) + 
[17:26:34.766]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:34.766]                   if (TRUE && !signal) {
[17:26:34.766]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.766]                     {
[17:26:34.766]                       inherits <- base::inherits
[17:26:34.766]                       invokeRestart <- base::invokeRestart
[17:26:34.766]                       is.null <- base::is.null
[17:26:34.766]                       muffled <- FALSE
[17:26:34.766]                       if (inherits(cond, "message")) {
[17:26:34.766]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:34.766]                         if (muffled) 
[17:26:34.766]                           invokeRestart("muffleMessage")
[17:26:34.766]                       }
[17:26:34.766]                       else if (inherits(cond, "warning")) {
[17:26:34.766]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:34.766]                         if (muffled) 
[17:26:34.766]                           invokeRestart("muffleWarning")
[17:26:34.766]                       }
[17:26:34.766]                       else if (inherits(cond, "condition")) {
[17:26:34.766]                         if (!is.null(pattern)) {
[17:26:34.766]                           computeRestarts <- base::computeRestarts
[17:26:34.766]                           grepl <- base::grepl
[17:26:34.766]                           restarts <- computeRestarts(cond)
[17:26:34.766]                           for (restart in restarts) {
[17:26:34.766]                             name <- restart$name
[17:26:34.766]                             if (is.null(name)) 
[17:26:34.766]                               next
[17:26:34.766]                             if (!grepl(pattern, name)) 
[17:26:34.766]                               next
[17:26:34.766]                             invokeRestart(restart)
[17:26:34.766]                             muffled <- TRUE
[17:26:34.766]                             break
[17:26:34.766]                           }
[17:26:34.766]                         }
[17:26:34.766]                       }
[17:26:34.766]                       invisible(muffled)
[17:26:34.766]                     }
[17:26:34.766]                     muffleCondition(cond, pattern = "^muffle")
[17:26:34.766]                   }
[17:26:34.766]                 }
[17:26:34.766]                 else {
[17:26:34.766]                   if (TRUE) {
[17:26:34.766]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.766]                     {
[17:26:34.766]                       inherits <- base::inherits
[17:26:34.766]                       invokeRestart <- base::invokeRestart
[17:26:34.766]                       is.null <- base::is.null
[17:26:34.766]                       muffled <- FALSE
[17:26:34.766]                       if (inherits(cond, "message")) {
[17:26:34.766]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:34.766]                         if (muffled) 
[17:26:34.766]                           invokeRestart("muffleMessage")
[17:26:34.766]                       }
[17:26:34.766]                       else if (inherits(cond, "warning")) {
[17:26:34.766]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:34.766]                         if (muffled) 
[17:26:34.766]                           invokeRestart("muffleWarning")
[17:26:34.766]                       }
[17:26:34.766]                       else if (inherits(cond, "condition")) {
[17:26:34.766]                         if (!is.null(pattern)) {
[17:26:34.766]                           computeRestarts <- base::computeRestarts
[17:26:34.766]                           grepl <- base::grepl
[17:26:34.766]                           restarts <- computeRestarts(cond)
[17:26:34.766]                           for (restart in restarts) {
[17:26:34.766]                             name <- restart$name
[17:26:34.766]                             if (is.null(name)) 
[17:26:34.766]                               next
[17:26:34.766]                             if (!grepl(pattern, name)) 
[17:26:34.766]                               next
[17:26:34.766]                             invokeRestart(restart)
[17:26:34.766]                             muffled <- TRUE
[17:26:34.766]                             break
[17:26:34.766]                           }
[17:26:34.766]                         }
[17:26:34.766]                       }
[17:26:34.766]                       invisible(muffled)
[17:26:34.766]                     }
[17:26:34.766]                     muffleCondition(cond, pattern = "^muffle")
[17:26:34.766]                   }
[17:26:34.766]                 }
[17:26:34.766]             }
[17:26:34.766]         }))
[17:26:34.766]     }, error = function(ex) {
[17:26:34.766]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:34.766]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:34.766]                 ...future.rng), started = ...future.startTime, 
[17:26:34.766]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:34.766]             version = "1.8"), class = "FutureResult")
[17:26:34.766]     }, finally = {
[17:26:34.766]         if (!identical(...future.workdir, getwd())) 
[17:26:34.766]             setwd(...future.workdir)
[17:26:34.766]         {
[17:26:34.766]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:34.766]                 ...future.oldOptions$nwarnings <- NULL
[17:26:34.766]             }
[17:26:34.766]             base::options(...future.oldOptions)
[17:26:34.766]             if (.Platform$OS.type == "windows") {
[17:26:34.766]                 old_names <- names(...future.oldEnvVars)
[17:26:34.766]                 envs <- base::Sys.getenv()
[17:26:34.766]                 names <- names(envs)
[17:26:34.766]                 common <- intersect(names, old_names)
[17:26:34.766]                 added <- setdiff(names, old_names)
[17:26:34.766]                 removed <- setdiff(old_names, names)
[17:26:34.766]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:34.766]                   envs[common]]
[17:26:34.766]                 NAMES <- toupper(changed)
[17:26:34.766]                 args <- list()
[17:26:34.766]                 for (kk in seq_along(NAMES)) {
[17:26:34.766]                   name <- changed[[kk]]
[17:26:34.766]                   NAME <- NAMES[[kk]]
[17:26:34.766]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.766]                     next
[17:26:34.766]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:34.766]                 }
[17:26:34.766]                 NAMES <- toupper(added)
[17:26:34.766]                 for (kk in seq_along(NAMES)) {
[17:26:34.766]                   name <- added[[kk]]
[17:26:34.766]                   NAME <- NAMES[[kk]]
[17:26:34.766]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.766]                     next
[17:26:34.766]                   args[[name]] <- ""
[17:26:34.766]                 }
[17:26:34.766]                 NAMES <- toupper(removed)
[17:26:34.766]                 for (kk in seq_along(NAMES)) {
[17:26:34.766]                   name <- removed[[kk]]
[17:26:34.766]                   NAME <- NAMES[[kk]]
[17:26:34.766]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.766]                     next
[17:26:34.766]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:34.766]                 }
[17:26:34.766]                 if (length(args) > 0) 
[17:26:34.766]                   base::do.call(base::Sys.setenv, args = args)
[17:26:34.766]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:34.766]             }
[17:26:34.766]             else {
[17:26:34.766]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:34.766]             }
[17:26:34.766]             {
[17:26:34.766]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:34.766]                   0L) {
[17:26:34.766]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:34.766]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:34.766]                   base::options(opts)
[17:26:34.766]                 }
[17:26:34.766]                 {
[17:26:34.766]                   {
[17:26:34.766]                     NULL
[17:26:34.766]                     RNGkind("Mersenne-Twister")
[17:26:34.766]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:34.766]                       inherits = FALSE)
[17:26:34.766]                   }
[17:26:34.766]                   options(future.plan = NULL)
[17:26:34.766]                   if (is.na(NA_character_)) 
[17:26:34.766]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:34.766]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:34.766]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:34.766]                     .init = FALSE)
[17:26:34.766]                 }
[17:26:34.766]             }
[17:26:34.766]         }
[17:26:34.766]     })
[17:26:34.766]     if (TRUE) {
[17:26:34.766]         base::sink(type = "output", split = FALSE)
[17:26:34.766]         if (TRUE) {
[17:26:34.766]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:34.766]         }
[17:26:34.766]         else {
[17:26:34.766]             ...future.result["stdout"] <- base::list(NULL)
[17:26:34.766]         }
[17:26:34.766]         base::close(...future.stdout)
[17:26:34.766]         ...future.stdout <- NULL
[17:26:34.766]     }
[17:26:34.766]     ...future.result$conditions <- ...future.conditions
[17:26:34.766]     ...future.result$finished <- base::Sys.time()
[17:26:34.766]     ...future.result
[17:26:34.766] }
[17:26:34.769] assign_globals() ...
[17:26:34.769] List of 1
[17:26:34.769]  $ ii: int 3
[17:26:34.769]  - attr(*, "where")=List of 1
[17:26:34.769]   ..$ ii:<environment: R_EmptyEnv> 
[17:26:34.769]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:26:34.769]  - attr(*, "resolved")= logi FALSE
[17:26:34.769]  - attr(*, "total_size")= num 56
[17:26:34.769]  - attr(*, "already-done")= logi TRUE
[17:26:34.772] - copied 'ii' to environment
[17:26:34.772] assign_globals() ... done
[17:26:34.773] plan(): Setting new future strategy stack:
[17:26:34.773] List of future strategies:
[17:26:34.773] 1. sequential:
[17:26:34.773]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:34.773]    - tweaked: FALSE
[17:26:34.773]    - call: NULL
[17:26:34.774] plan(): nbrOfWorkers() = 1
[17:26:34.775] plan(): Setting new future strategy stack:
[17:26:34.775] List of future strategies:
[17:26:34.775] 1. sequential:
[17:26:34.775]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:34.775]    - tweaked: FALSE
[17:26:34.775]    - call: plan(strategy)
[17:26:34.775] plan(): nbrOfWorkers() = 1
[17:26:34.776] SequentialFuture started (and completed)
[17:26:34.776] - Launch lazy future ... done
[17:26:34.776] run() for 'SequentialFuture' ... done
[17:26:34.777] signalConditions() ...
[17:26:34.777]  - include = 'immediateCondition'
[17:26:34.777]  - exclude = 
[17:26:34.777]  - resignal = FALSE
[17:26:34.777]  - Number of conditions: 1
[17:26:34.777] signalConditions() ... done
[17:26:34.778] Future state: 'finished'
[17:26:34.778] signalConditions() ...
[17:26:34.778]  - include = 'condition'
[17:26:34.778]  - exclude = 'immediateCondition'
[17:26:34.778]  - resignal = TRUE
[17:26:34.779]  - Number of conditions: 1
[17:26:34.779]  - Condition #1: 'simpleError', 'error', 'condition'
[17:26:34.779] signalConditions() ... done
Warning in get(var, envir = x, inherits = FALSE) :
  restarting interrupted promise evaluation
[17:26:34.780] signalConditions() ...
[17:26:34.780]  - include = 'immediateCondition'
[17:26:34.780]  - exclude = 
[17:26:34.781]  - resignal = FALSE
[17:26:34.781]  - Number of conditions: 1
[17:26:34.781] signalConditions() ... done
[17:26:34.781] Future state: 'finished'
[17:26:34.781] signalConditions() ...
[17:26:34.781]  - include = 'condition'
[17:26:34.782]  - exclude = 'immediateCondition'
[17:26:34.782]  - resignal = TRUE
[17:26:34.782]  - Number of conditions: 1
[17:26:34.782]  - Condition #1: 'simpleError', 'error', 'condition'
[17:26:34.782] signalConditions() ... done
Warning in get(var, envir = x, inherits = FALSE) :
  restarting interrupted promise evaluation
[17:26:34.783] signalConditions() ...
[17:26:34.783]  - include = 'immediateCondition'
[17:26:34.783]  - exclude = 
[17:26:34.783]  - resignal = FALSE
[17:26:34.784]  - Number of conditions: 1
[17:26:34.784] signalConditions() ... done
[17:26:34.784] Future state: 'finished'
[17:26:34.784] signalConditions() ...
[17:26:34.784]  - include = 'condition'
[17:26:34.784]  - exclude = 'immediateCondition'
[17:26:34.785]  - resignal = TRUE
[17:26:34.785]  - Number of conditions: 1
[17:26:34.785]  - Condition #1: 'simpleError', 'error', 'condition'
[17:26:34.785] signalConditions() ... done
** Future evaluation with a poor-man's "progress bar"
[17:26:34.785] getGlobalsAndPackages() ...
[17:26:34.786] Searching for globals...
[17:26:34.789] - globals found: [4] '{', 'cat', 'for', ':'
[17:26:34.789] Searching for globals ... DONE
[17:26:34.789] Resolving globals: FALSE
[17:26:34.790] 
[17:26:34.790] 
[17:26:34.790] getGlobalsAndPackages() ... DONE
[17:26:34.790] run() for 'Future' ...
[17:26:34.790] - state: 'created'
[17:26:34.791] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:34.791] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:34.791] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:34.791]   - Field: 'label'
[17:26:34.792]   - Field: 'local'
[17:26:34.792]   - Field: 'owner'
[17:26:34.792]   - Field: 'envir'
[17:26:34.792]   - Field: 'packages'
[17:26:34.792]   - Field: 'gc'
[17:26:34.792]   - Field: 'conditions'
[17:26:34.793]   - Field: 'expr'
[17:26:34.793]   - Field: 'uuid'
[17:26:34.793]   - Field: 'seed'
[17:26:34.793]   - Field: 'version'
[17:26:34.793]   - Field: 'result'
[17:26:34.794]   - Field: 'asynchronous'
[17:26:34.794]   - Field: 'calls'
[17:26:34.794]   - Field: 'globals'
[17:26:34.794]   - Field: 'stdout'
[17:26:34.794]   - Field: 'earlySignal'
[17:26:34.794]   - Field: 'lazy'
[17:26:34.795]   - Field: 'state'
[17:26:34.795] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:34.795] - Launch lazy future ...
[17:26:34.795] Packages needed by the future expression (n = 0): <none>
[17:26:34.795] Packages needed by future strategies (n = 0): <none>
[17:26:34.796] {
[17:26:34.796]     {
[17:26:34.796]         {
[17:26:34.796]             ...future.startTime <- base::Sys.time()
[17:26:34.796]             {
[17:26:34.796]                 {
[17:26:34.796]                   {
[17:26:34.796]                     base::local({
[17:26:34.796]                       has_future <- base::requireNamespace("future", 
[17:26:34.796]                         quietly = TRUE)
[17:26:34.796]                       if (has_future) {
[17:26:34.796]                         ns <- base::getNamespace("future")
[17:26:34.796]                         version <- ns[[".package"]][["version"]]
[17:26:34.796]                         if (is.null(version)) 
[17:26:34.796]                           version <- utils::packageVersion("future")
[17:26:34.796]                       }
[17:26:34.796]                       else {
[17:26:34.796]                         version <- NULL
[17:26:34.796]                       }
[17:26:34.796]                       if (!has_future || version < "1.8.0") {
[17:26:34.796]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:34.796]                           "", base::R.version$version.string), 
[17:26:34.796]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:34.796]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:34.796]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:34.796]                             "release", "version")], collapse = " "), 
[17:26:34.796]                           hostname = base::Sys.info()[["nodename"]])
[17:26:34.796]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:34.796]                           info)
[17:26:34.796]                         info <- base::paste(info, collapse = "; ")
[17:26:34.796]                         if (!has_future) {
[17:26:34.796]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:34.796]                             info)
[17:26:34.796]                         }
[17:26:34.796]                         else {
[17:26:34.796]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:34.796]                             info, version)
[17:26:34.796]                         }
[17:26:34.796]                         base::stop(msg)
[17:26:34.796]                       }
[17:26:34.796]                     })
[17:26:34.796]                   }
[17:26:34.796]                   ...future.strategy.old <- future::plan("list")
[17:26:34.796]                   options(future.plan = NULL)
[17:26:34.796]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:34.796]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:34.796]                 }
[17:26:34.796]                 ...future.workdir <- getwd()
[17:26:34.796]             }
[17:26:34.796]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:34.796]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:34.796]         }
[17:26:34.796]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:34.796]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:34.796]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:34.796]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:34.796]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:34.796]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:34.796]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:34.796]             base::names(...future.oldOptions))
[17:26:34.796]     }
[17:26:34.796]     if (FALSE) {
[17:26:34.796]     }
[17:26:34.796]     else {
[17:26:34.796]         if (TRUE) {
[17:26:34.796]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:34.796]                 open = "w")
[17:26:34.796]         }
[17:26:34.796]         else {
[17:26:34.796]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:34.796]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:34.796]         }
[17:26:34.796]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:34.796]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:34.796]             base::sink(type = "output", split = FALSE)
[17:26:34.796]             base::close(...future.stdout)
[17:26:34.796]         }, add = TRUE)
[17:26:34.796]     }
[17:26:34.796]     ...future.frame <- base::sys.nframe()
[17:26:34.796]     ...future.conditions <- base::list()
[17:26:34.796]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:34.796]     if (FALSE) {
[17:26:34.796]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:34.796]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:34.796]     }
[17:26:34.796]     ...future.result <- base::tryCatch({
[17:26:34.796]         base::withCallingHandlers({
[17:26:34.796]             ...future.value <- base::withVisible(base::local({
[17:26:34.796]                 cat("Processing: ")
[17:26:34.796]                 for (ii in 1:10) {
[17:26:34.796]                   cat(".")
[17:26:34.796]                 }
[17:26:34.796]                 cat(" [100%]\n")
[17:26:34.796]                 4
[17:26:34.796]             }))
[17:26:34.796]             future::FutureResult(value = ...future.value$value, 
[17:26:34.796]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:34.796]                   ...future.rng), globalenv = if (FALSE) 
[17:26:34.796]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:34.796]                     ...future.globalenv.names))
[17:26:34.796]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:34.796]         }, condition = base::local({
[17:26:34.796]             c <- base::c
[17:26:34.796]             inherits <- base::inherits
[17:26:34.796]             invokeRestart <- base::invokeRestart
[17:26:34.796]             length <- base::length
[17:26:34.796]             list <- base::list
[17:26:34.796]             seq.int <- base::seq.int
[17:26:34.796]             signalCondition <- base::signalCondition
[17:26:34.796]             sys.calls <- base::sys.calls
[17:26:34.796]             `[[` <- base::`[[`
[17:26:34.796]             `+` <- base::`+`
[17:26:34.796]             `<<-` <- base::`<<-`
[17:26:34.796]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:34.796]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:34.796]                   3L)]
[17:26:34.796]             }
[17:26:34.796]             function(cond) {
[17:26:34.796]                 is_error <- inherits(cond, "error")
[17:26:34.796]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:34.796]                   NULL)
[17:26:34.796]                 if (is_error) {
[17:26:34.796]                   sessionInformation <- function() {
[17:26:34.796]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:34.796]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:34.796]                       search = base::search(), system = base::Sys.info())
[17:26:34.796]                   }
[17:26:34.796]                   ...future.conditions[[length(...future.conditions) + 
[17:26:34.796]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:34.796]                     cond$call), session = sessionInformation(), 
[17:26:34.796]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:34.796]                   signalCondition(cond)
[17:26:34.796]                 }
[17:26:34.796]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:34.796]                 "immediateCondition"))) {
[17:26:34.796]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:34.796]                   ...future.conditions[[length(...future.conditions) + 
[17:26:34.796]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:34.796]                   if (TRUE && !signal) {
[17:26:34.796]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.796]                     {
[17:26:34.796]                       inherits <- base::inherits
[17:26:34.796]                       invokeRestart <- base::invokeRestart
[17:26:34.796]                       is.null <- base::is.null
[17:26:34.796]                       muffled <- FALSE
[17:26:34.796]                       if (inherits(cond, "message")) {
[17:26:34.796]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:34.796]                         if (muffled) 
[17:26:34.796]                           invokeRestart("muffleMessage")
[17:26:34.796]                       }
[17:26:34.796]                       else if (inherits(cond, "warning")) {
[17:26:34.796]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:34.796]                         if (muffled) 
[17:26:34.796]                           invokeRestart("muffleWarning")
[17:26:34.796]                       }
[17:26:34.796]                       else if (inherits(cond, "condition")) {
[17:26:34.796]                         if (!is.null(pattern)) {
[17:26:34.796]                           computeRestarts <- base::computeRestarts
[17:26:34.796]                           grepl <- base::grepl
[17:26:34.796]                           restarts <- computeRestarts(cond)
[17:26:34.796]                           for (restart in restarts) {
[17:26:34.796]                             name <- restart$name
[17:26:34.796]                             if (is.null(name)) 
[17:26:34.796]                               next
[17:26:34.796]                             if (!grepl(pattern, name)) 
[17:26:34.796]                               next
[17:26:34.796]                             invokeRestart(restart)
[17:26:34.796]                             muffled <- TRUE
[17:26:34.796]                             break
[17:26:34.796]                           }
[17:26:34.796]                         }
[17:26:34.796]                       }
[17:26:34.796]                       invisible(muffled)
[17:26:34.796]                     }
[17:26:34.796]                     muffleCondition(cond, pattern = "^muffle")
[17:26:34.796]                   }
[17:26:34.796]                 }
[17:26:34.796]                 else {
[17:26:34.796]                   if (TRUE) {
[17:26:34.796]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.796]                     {
[17:26:34.796]                       inherits <- base::inherits
[17:26:34.796]                       invokeRestart <- base::invokeRestart
[17:26:34.796]                       is.null <- base::is.null
[17:26:34.796]                       muffled <- FALSE
[17:26:34.796]                       if (inherits(cond, "message")) {
[17:26:34.796]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:34.796]                         if (muffled) 
[17:26:34.796]                           invokeRestart("muffleMessage")
[17:26:34.796]                       }
[17:26:34.796]                       else if (inherits(cond, "warning")) {
[17:26:34.796]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:34.796]                         if (muffled) 
[17:26:34.796]                           invokeRestart("muffleWarning")
[17:26:34.796]                       }
[17:26:34.796]                       else if (inherits(cond, "condition")) {
[17:26:34.796]                         if (!is.null(pattern)) {
[17:26:34.796]                           computeRestarts <- base::computeRestarts
[17:26:34.796]                           grepl <- base::grepl
[17:26:34.796]                           restarts <- computeRestarts(cond)
[17:26:34.796]                           for (restart in restarts) {
[17:26:34.796]                             name <- restart$name
[17:26:34.796]                             if (is.null(name)) 
[17:26:34.796]                               next
[17:26:34.796]                             if (!grepl(pattern, name)) 
[17:26:34.796]                               next
[17:26:34.796]                             invokeRestart(restart)
[17:26:34.796]                             muffled <- TRUE
[17:26:34.796]                             break
[17:26:34.796]                           }
[17:26:34.796]                         }
[17:26:34.796]                       }
[17:26:34.796]                       invisible(muffled)
[17:26:34.796]                     }
[17:26:34.796]                     muffleCondition(cond, pattern = "^muffle")
[17:26:34.796]                   }
[17:26:34.796]                 }
[17:26:34.796]             }
[17:26:34.796]         }))
[17:26:34.796]     }, error = function(ex) {
[17:26:34.796]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:34.796]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:34.796]                 ...future.rng), started = ...future.startTime, 
[17:26:34.796]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:34.796]             version = "1.8"), class = "FutureResult")
[17:26:34.796]     }, finally = {
[17:26:34.796]         if (!identical(...future.workdir, getwd())) 
[17:26:34.796]             setwd(...future.workdir)
[17:26:34.796]         {
[17:26:34.796]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:34.796]                 ...future.oldOptions$nwarnings <- NULL
[17:26:34.796]             }
[17:26:34.796]             base::options(...future.oldOptions)
[17:26:34.796]             if (.Platform$OS.type == "windows") {
[17:26:34.796]                 old_names <- names(...future.oldEnvVars)
[17:26:34.796]                 envs <- base::Sys.getenv()
[17:26:34.796]                 names <- names(envs)
[17:26:34.796]                 common <- intersect(names, old_names)
[17:26:34.796]                 added <- setdiff(names, old_names)
[17:26:34.796]                 removed <- setdiff(old_names, names)
[17:26:34.796]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:34.796]                   envs[common]]
[17:26:34.796]                 NAMES <- toupper(changed)
[17:26:34.796]                 args <- list()
[17:26:34.796]                 for (kk in seq_along(NAMES)) {
[17:26:34.796]                   name <- changed[[kk]]
[17:26:34.796]                   NAME <- NAMES[[kk]]
[17:26:34.796]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.796]                     next
[17:26:34.796]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:34.796]                 }
[17:26:34.796]                 NAMES <- toupper(added)
[17:26:34.796]                 for (kk in seq_along(NAMES)) {
[17:26:34.796]                   name <- added[[kk]]
[17:26:34.796]                   NAME <- NAMES[[kk]]
[17:26:34.796]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.796]                     next
[17:26:34.796]                   args[[name]] <- ""
[17:26:34.796]                 }
[17:26:34.796]                 NAMES <- toupper(removed)
[17:26:34.796]                 for (kk in seq_along(NAMES)) {
[17:26:34.796]                   name <- removed[[kk]]
[17:26:34.796]                   NAME <- NAMES[[kk]]
[17:26:34.796]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.796]                     next
[17:26:34.796]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:34.796]                 }
[17:26:34.796]                 if (length(args) > 0) 
[17:26:34.796]                   base::do.call(base::Sys.setenv, args = args)
[17:26:34.796]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:34.796]             }
[17:26:34.796]             else {
[17:26:34.796]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:34.796]             }
[17:26:34.796]             {
[17:26:34.796]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:34.796]                   0L) {
[17:26:34.796]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:34.796]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:34.796]                   base::options(opts)
[17:26:34.796]                 }
[17:26:34.796]                 {
[17:26:34.796]                   {
[17:26:34.796]                     NULL
[17:26:34.796]                     RNGkind("Mersenne-Twister")
[17:26:34.796]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:34.796]                       inherits = FALSE)
[17:26:34.796]                   }
[17:26:34.796]                   options(future.plan = NULL)
[17:26:34.796]                   if (is.na(NA_character_)) 
[17:26:34.796]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:34.796]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:34.796]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:34.796]                     .init = FALSE)
[17:26:34.796]                 }
[17:26:34.796]             }
[17:26:34.796]         }
[17:26:34.796]     })
[17:26:34.796]     if (TRUE) {
[17:26:34.796]         base::sink(type = "output", split = FALSE)
[17:26:34.796]         if (TRUE) {
[17:26:34.796]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:34.796]         }
[17:26:34.796]         else {
[17:26:34.796]             ...future.result["stdout"] <- base::list(NULL)
[17:26:34.796]         }
[17:26:34.796]         base::close(...future.stdout)
[17:26:34.796]         ...future.stdout <- NULL
[17:26:34.796]     }
[17:26:34.796]     ...future.result$conditions <- ...future.conditions
[17:26:34.796]     ...future.result$finished <- base::Sys.time()
[17:26:34.796]     ...future.result
[17:26:34.796] }
[17:26:34.800] plan(): Setting new future strategy stack:
[17:26:34.800] List of future strategies:
[17:26:34.800] 1. sequential:
[17:26:34.800]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:34.800]    - tweaked: FALSE
[17:26:34.800]    - call: NULL
[17:26:34.801] plan(): nbrOfWorkers() = 1
[17:26:34.802] plan(): Setting new future strategy stack:
[17:26:34.802] List of future strategies:
[17:26:34.802] 1. sequential:
[17:26:34.802]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:34.802]    - tweaked: FALSE
[17:26:34.802]    - call: plan(strategy)
[17:26:34.803] plan(): nbrOfWorkers() = 1
[17:26:34.803] SequentialFuture started (and completed)
[17:26:34.803] - Launch lazy future ... done
[17:26:34.803] run() for 'SequentialFuture' ... done
** Collecting results
v1 = 1
v2 = 2
Warning in sprintf(...) : restarting interrupted promise evaluation
[17:26:34.805] signalConditions() ...
[17:26:34.805]  - include = 'immediateCondition'
[17:26:34.805]  - exclude = 
[17:26:34.805]  - resignal = FALSE
[17:26:34.805]  - Number of conditions: 1
[17:26:34.806] signalConditions() ... done
[17:26:34.806] Future state: 'finished'
[17:26:34.806] signalConditions() ...
[17:26:34.806]  - include = 'condition'
[17:26:34.806]  - exclude = 'immediateCondition'
[17:26:34.807]  - resignal = TRUE
[17:26:34.807]  - Number of conditions: 1
[17:26:34.807]  - Condition #1: 'simpleError', 'error', 'condition'
[17:26:34.807] signalConditions() ... done
v3: <simpleError> (as expect)
Processing: .......... [100%]
v4 = 4
** Left-to-right and right-to-left future assignments
[17:26:34.808] getGlobalsAndPackages() ...
[17:26:34.808] Searching for globals...
[17:26:34.808] 
[17:26:34.808] Searching for globals ... DONE
[17:26:34.809] - globals: [0] <none>
[17:26:34.809] getGlobalsAndPackages() ... DONE
[17:26:34.809] run() for 'Future' ...
[17:26:34.809] - state: 'created'
[17:26:34.809] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:34.810] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:34.810] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:34.810]   - Field: 'label'
[17:26:34.810]   - Field: 'local'
[17:26:34.810]   - Field: 'owner'
[17:26:34.811]   - Field: 'envir'
[17:26:34.811]   - Field: 'packages'
[17:26:34.811]   - Field: 'gc'
[17:26:34.811]   - Field: 'conditions'
[17:26:34.811]   - Field: 'expr'
[17:26:34.811]   - Field: 'uuid'
[17:26:34.812]   - Field: 'seed'
[17:26:34.812]   - Field: 'version'
[17:26:34.812]   - Field: 'result'
[17:26:34.812]   - Field: 'asynchronous'
[17:26:34.812]   - Field: 'calls'
[17:26:34.812]   - Field: 'globals'
[17:26:34.813]   - Field: 'stdout'
[17:26:34.813]   - Field: 'earlySignal'
[17:26:34.813]   - Field: 'lazy'
[17:26:34.813]   - Field: 'state'
[17:26:34.813] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:34.813] - Launch lazy future ...
[17:26:34.814] Packages needed by the future expression (n = 0): <none>
[17:26:34.814] Packages needed by future strategies (n = 0): <none>
[17:26:34.814] {
[17:26:34.814]     {
[17:26:34.814]         {
[17:26:34.814]             ...future.startTime <- base::Sys.time()
[17:26:34.814]             {
[17:26:34.814]                 {
[17:26:34.814]                   {
[17:26:34.814]                     base::local({
[17:26:34.814]                       has_future <- base::requireNamespace("future", 
[17:26:34.814]                         quietly = TRUE)
[17:26:34.814]                       if (has_future) {
[17:26:34.814]                         ns <- base::getNamespace("future")
[17:26:34.814]                         version <- ns[[".package"]][["version"]]
[17:26:34.814]                         if (is.null(version)) 
[17:26:34.814]                           version <- utils::packageVersion("future")
[17:26:34.814]                       }
[17:26:34.814]                       else {
[17:26:34.814]                         version <- NULL
[17:26:34.814]                       }
[17:26:34.814]                       if (!has_future || version < "1.8.0") {
[17:26:34.814]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:34.814]                           "", base::R.version$version.string), 
[17:26:34.814]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:34.814]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:34.814]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:34.814]                             "release", "version")], collapse = " "), 
[17:26:34.814]                           hostname = base::Sys.info()[["nodename"]])
[17:26:34.814]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:34.814]                           info)
[17:26:34.814]                         info <- base::paste(info, collapse = "; ")
[17:26:34.814]                         if (!has_future) {
[17:26:34.814]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:34.814]                             info)
[17:26:34.814]                         }
[17:26:34.814]                         else {
[17:26:34.814]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:34.814]                             info, version)
[17:26:34.814]                         }
[17:26:34.814]                         base::stop(msg)
[17:26:34.814]                       }
[17:26:34.814]                     })
[17:26:34.814]                   }
[17:26:34.814]                   ...future.strategy.old <- future::plan("list")
[17:26:34.814]                   options(future.plan = NULL)
[17:26:34.814]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:34.814]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:34.814]                 }
[17:26:34.814]                 ...future.workdir <- getwd()
[17:26:34.814]             }
[17:26:34.814]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:34.814]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:34.814]         }
[17:26:34.814]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:34.814]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:34.814]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:34.814]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:34.814]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:34.814]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:34.814]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:34.814]             base::names(...future.oldOptions))
[17:26:34.814]     }
[17:26:34.814]     if (FALSE) {
[17:26:34.814]     }
[17:26:34.814]     else {
[17:26:34.814]         if (TRUE) {
[17:26:34.814]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:34.814]                 open = "w")
[17:26:34.814]         }
[17:26:34.814]         else {
[17:26:34.814]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:34.814]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:34.814]         }
[17:26:34.814]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:34.814]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:34.814]             base::sink(type = "output", split = FALSE)
[17:26:34.814]             base::close(...future.stdout)
[17:26:34.814]         }, add = TRUE)
[17:26:34.814]     }
[17:26:34.814]     ...future.frame <- base::sys.nframe()
[17:26:34.814]     ...future.conditions <- base::list()
[17:26:34.814]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:34.814]     if (FALSE) {
[17:26:34.814]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:34.814]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:34.814]     }
[17:26:34.814]     ...future.result <- base::tryCatch({
[17:26:34.814]         base::withCallingHandlers({
[17:26:34.814]             ...future.value <- base::withVisible(base::local(1))
[17:26:34.814]             future::FutureResult(value = ...future.value$value, 
[17:26:34.814]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:34.814]                   ...future.rng), globalenv = if (FALSE) 
[17:26:34.814]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:34.814]                     ...future.globalenv.names))
[17:26:34.814]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:34.814]         }, condition = base::local({
[17:26:34.814]             c <- base::c
[17:26:34.814]             inherits <- base::inherits
[17:26:34.814]             invokeRestart <- base::invokeRestart
[17:26:34.814]             length <- base::length
[17:26:34.814]             list <- base::list
[17:26:34.814]             seq.int <- base::seq.int
[17:26:34.814]             signalCondition <- base::signalCondition
[17:26:34.814]             sys.calls <- base::sys.calls
[17:26:34.814]             `[[` <- base::`[[`
[17:26:34.814]             `+` <- base::`+`
[17:26:34.814]             `<<-` <- base::`<<-`
[17:26:34.814]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:34.814]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:34.814]                   3L)]
[17:26:34.814]             }
[17:26:34.814]             function(cond) {
[17:26:34.814]                 is_error <- inherits(cond, "error")
[17:26:34.814]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:34.814]                   NULL)
[17:26:34.814]                 if (is_error) {
[17:26:34.814]                   sessionInformation <- function() {
[17:26:34.814]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:34.814]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:34.814]                       search = base::search(), system = base::Sys.info())
[17:26:34.814]                   }
[17:26:34.814]                   ...future.conditions[[length(...future.conditions) + 
[17:26:34.814]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:34.814]                     cond$call), session = sessionInformation(), 
[17:26:34.814]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:34.814]                   signalCondition(cond)
[17:26:34.814]                 }
[17:26:34.814]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:34.814]                 "immediateCondition"))) {
[17:26:34.814]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:34.814]                   ...future.conditions[[length(...future.conditions) + 
[17:26:34.814]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:34.814]                   if (TRUE && !signal) {
[17:26:34.814]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.814]                     {
[17:26:34.814]                       inherits <- base::inherits
[17:26:34.814]                       invokeRestart <- base::invokeRestart
[17:26:34.814]                       is.null <- base::is.null
[17:26:34.814]                       muffled <- FALSE
[17:26:34.814]                       if (inherits(cond, "message")) {
[17:26:34.814]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:34.814]                         if (muffled) 
[17:26:34.814]                           invokeRestart("muffleMessage")
[17:26:34.814]                       }
[17:26:34.814]                       else if (inherits(cond, "warning")) {
[17:26:34.814]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:34.814]                         if (muffled) 
[17:26:34.814]                           invokeRestart("muffleWarning")
[17:26:34.814]                       }
[17:26:34.814]                       else if (inherits(cond, "condition")) {
[17:26:34.814]                         if (!is.null(pattern)) {
[17:26:34.814]                           computeRestarts <- base::computeRestarts
[17:26:34.814]                           grepl <- base::grepl
[17:26:34.814]                           restarts <- computeRestarts(cond)
[17:26:34.814]                           for (restart in restarts) {
[17:26:34.814]                             name <- restart$name
[17:26:34.814]                             if (is.null(name)) 
[17:26:34.814]                               next
[17:26:34.814]                             if (!grepl(pattern, name)) 
[17:26:34.814]                               next
[17:26:34.814]                             invokeRestart(restart)
[17:26:34.814]                             muffled <- TRUE
[17:26:34.814]                             break
[17:26:34.814]                           }
[17:26:34.814]                         }
[17:26:34.814]                       }
[17:26:34.814]                       invisible(muffled)
[17:26:34.814]                     }
[17:26:34.814]                     muffleCondition(cond, pattern = "^muffle")
[17:26:34.814]                   }
[17:26:34.814]                 }
[17:26:34.814]                 else {
[17:26:34.814]                   if (TRUE) {
[17:26:34.814]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.814]                     {
[17:26:34.814]                       inherits <- base::inherits
[17:26:34.814]                       invokeRestart <- base::invokeRestart
[17:26:34.814]                       is.null <- base::is.null
[17:26:34.814]                       muffled <- FALSE
[17:26:34.814]                       if (inherits(cond, "message")) {
[17:26:34.814]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:34.814]                         if (muffled) 
[17:26:34.814]                           invokeRestart("muffleMessage")
[17:26:34.814]                       }
[17:26:34.814]                       else if (inherits(cond, "warning")) {
[17:26:34.814]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:34.814]                         if (muffled) 
[17:26:34.814]                           invokeRestart("muffleWarning")
[17:26:34.814]                       }
[17:26:34.814]                       else if (inherits(cond, "condition")) {
[17:26:34.814]                         if (!is.null(pattern)) {
[17:26:34.814]                           computeRestarts <- base::computeRestarts
[17:26:34.814]                           grepl <- base::grepl
[17:26:34.814]                           restarts <- computeRestarts(cond)
[17:26:34.814]                           for (restart in restarts) {
[17:26:34.814]                             name <- restart$name
[17:26:34.814]                             if (is.null(name)) 
[17:26:34.814]                               next
[17:26:34.814]                             if (!grepl(pattern, name)) 
[17:26:34.814]                               next
[17:26:34.814]                             invokeRestart(restart)
[17:26:34.814]                             muffled <- TRUE
[17:26:34.814]                             break
[17:26:34.814]                           }
[17:26:34.814]                         }
[17:26:34.814]                       }
[17:26:34.814]                       invisible(muffled)
[17:26:34.814]                     }
[17:26:34.814]                     muffleCondition(cond, pattern = "^muffle")
[17:26:34.814]                   }
[17:26:34.814]                 }
[17:26:34.814]             }
[17:26:34.814]         }))
[17:26:34.814]     }, error = function(ex) {
[17:26:34.814]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:34.814]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:34.814]                 ...future.rng), started = ...future.startTime, 
[17:26:34.814]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:34.814]             version = "1.8"), class = "FutureResult")
[17:26:34.814]     }, finally = {
[17:26:34.814]         if (!identical(...future.workdir, getwd())) 
[17:26:34.814]             setwd(...future.workdir)
[17:26:34.814]         {
[17:26:34.814]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:34.814]                 ...future.oldOptions$nwarnings <- NULL
[17:26:34.814]             }
[17:26:34.814]             base::options(...future.oldOptions)
[17:26:34.814]             if (.Platform$OS.type == "windows") {
[17:26:34.814]                 old_names <- names(...future.oldEnvVars)
[17:26:34.814]                 envs <- base::Sys.getenv()
[17:26:34.814]                 names <- names(envs)
[17:26:34.814]                 common <- intersect(names, old_names)
[17:26:34.814]                 added <- setdiff(names, old_names)
[17:26:34.814]                 removed <- setdiff(old_names, names)
[17:26:34.814]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:34.814]                   envs[common]]
[17:26:34.814]                 NAMES <- toupper(changed)
[17:26:34.814]                 args <- list()
[17:26:34.814]                 for (kk in seq_along(NAMES)) {
[17:26:34.814]                   name <- changed[[kk]]
[17:26:34.814]                   NAME <- NAMES[[kk]]
[17:26:34.814]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.814]                     next
[17:26:34.814]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:34.814]                 }
[17:26:34.814]                 NAMES <- toupper(added)
[17:26:34.814]                 for (kk in seq_along(NAMES)) {
[17:26:34.814]                   name <- added[[kk]]
[17:26:34.814]                   NAME <- NAMES[[kk]]
[17:26:34.814]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.814]                     next
[17:26:34.814]                   args[[name]] <- ""
[17:26:34.814]                 }
[17:26:34.814]                 NAMES <- toupper(removed)
[17:26:34.814]                 for (kk in seq_along(NAMES)) {
[17:26:34.814]                   name <- removed[[kk]]
[17:26:34.814]                   NAME <- NAMES[[kk]]
[17:26:34.814]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.814]                     next
[17:26:34.814]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:34.814]                 }
[17:26:34.814]                 if (length(args) > 0) 
[17:26:34.814]                   base::do.call(base::Sys.setenv, args = args)
[17:26:34.814]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:34.814]             }
[17:26:34.814]             else {
[17:26:34.814]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:34.814]             }
[17:26:34.814]             {
[17:26:34.814]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:34.814]                   0L) {
[17:26:34.814]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:34.814]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:34.814]                   base::options(opts)
[17:26:34.814]                 }
[17:26:34.814]                 {
[17:26:34.814]                   {
[17:26:34.814]                     NULL
[17:26:34.814]                     RNGkind("Mersenne-Twister")
[17:26:34.814]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:34.814]                       inherits = FALSE)
[17:26:34.814]                   }
[17:26:34.814]                   options(future.plan = NULL)
[17:26:34.814]                   if (is.na(NA_character_)) 
[17:26:34.814]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:34.814]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:34.814]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:34.814]                     .init = FALSE)
[17:26:34.814]                 }
[17:26:34.814]             }
[17:26:34.814]         }
[17:26:34.814]     })
[17:26:34.814]     if (TRUE) {
[17:26:34.814]         base::sink(type = "output", split = FALSE)
[17:26:34.814]         if (TRUE) {
[17:26:34.814]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:34.814]         }
[17:26:34.814]         else {
[17:26:34.814]             ...future.result["stdout"] <- base::list(NULL)
[17:26:34.814]         }
[17:26:34.814]         base::close(...future.stdout)
[17:26:34.814]         ...future.stdout <- NULL
[17:26:34.814]     }
[17:26:34.814]     ...future.result$conditions <- ...future.conditions
[17:26:34.814]     ...future.result$finished <- base::Sys.time()
[17:26:34.814]     ...future.result
[17:26:34.814] }
[17:26:34.818] plan(): Setting new future strategy stack:
[17:26:34.818] List of future strategies:
[17:26:34.818] 1. sequential:
[17:26:34.818]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:34.818]    - tweaked: FALSE
[17:26:34.818]    - call: NULL
[17:26:34.819] plan(): nbrOfWorkers() = 1
[17:26:34.820] plan(): Setting new future strategy stack:
[17:26:34.820] List of future strategies:
[17:26:34.820] 1. sequential:
[17:26:34.820]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:34.820]    - tweaked: FALSE
[17:26:34.820]    - call: plan(strategy)
[17:26:34.821] plan(): nbrOfWorkers() = 1
[17:26:34.821] SequentialFuture started (and completed)
[17:26:34.822] - Launch lazy future ... done
[17:26:34.822] run() for 'SequentialFuture' ... done
c = 1
[17:26:34.823] getGlobalsAndPackages() ...
[17:26:34.823] Searching for globals...
[17:26:34.824] 
[17:26:34.824] Searching for globals ... DONE
[17:26:34.824] - globals: [0] <none>
[17:26:34.824] getGlobalsAndPackages() ... DONE
[17:26:34.824] run() for 'Future' ...
[17:26:34.824] - state: 'created'
[17:26:34.825] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:34.825] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:34.825] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:34.825]   - Field: 'label'
[17:26:34.826]   - Field: 'local'
[17:26:34.826]   - Field: 'owner'
[17:26:34.826]   - Field: 'envir'
[17:26:34.826]   - Field: 'packages'
[17:26:34.826]   - Field: 'gc'
[17:26:34.826]   - Field: 'conditions'
[17:26:34.827]   - Field: 'expr'
[17:26:34.827]   - Field: 'uuid'
[17:26:34.827]   - Field: 'seed'
[17:26:34.827]   - Field: 'version'
[17:26:34.827]   - Field: 'result'
[17:26:34.827]   - Field: 'asynchronous'
[17:26:34.828]   - Field: 'calls'
[17:26:34.828]   - Field: 'globals'
[17:26:34.828]   - Field: 'stdout'
[17:26:34.828]   - Field: 'earlySignal'
[17:26:34.828]   - Field: 'lazy'
[17:26:34.828]   - Field: 'state'
[17:26:34.829] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:34.829] - Launch lazy future ...
[17:26:34.829] Packages needed by the future expression (n = 0): <none>
[17:26:34.829] Packages needed by future strategies (n = 0): <none>
[17:26:34.830] {
[17:26:34.830]     {
[17:26:34.830]         {
[17:26:34.830]             ...future.startTime <- base::Sys.time()
[17:26:34.830]             {
[17:26:34.830]                 {
[17:26:34.830]                   {
[17:26:34.830]                     base::local({
[17:26:34.830]                       has_future <- base::requireNamespace("future", 
[17:26:34.830]                         quietly = TRUE)
[17:26:34.830]                       if (has_future) {
[17:26:34.830]                         ns <- base::getNamespace("future")
[17:26:34.830]                         version <- ns[[".package"]][["version"]]
[17:26:34.830]                         if (is.null(version)) 
[17:26:34.830]                           version <- utils::packageVersion("future")
[17:26:34.830]                       }
[17:26:34.830]                       else {
[17:26:34.830]                         version <- NULL
[17:26:34.830]                       }
[17:26:34.830]                       if (!has_future || version < "1.8.0") {
[17:26:34.830]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:34.830]                           "", base::R.version$version.string), 
[17:26:34.830]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:34.830]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:34.830]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:34.830]                             "release", "version")], collapse = " "), 
[17:26:34.830]                           hostname = base::Sys.info()[["nodename"]])
[17:26:34.830]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:34.830]                           info)
[17:26:34.830]                         info <- base::paste(info, collapse = "; ")
[17:26:34.830]                         if (!has_future) {
[17:26:34.830]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:34.830]                             info)
[17:26:34.830]                         }
[17:26:34.830]                         else {
[17:26:34.830]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:34.830]                             info, version)
[17:26:34.830]                         }
[17:26:34.830]                         base::stop(msg)
[17:26:34.830]                       }
[17:26:34.830]                     })
[17:26:34.830]                   }
[17:26:34.830]                   ...future.strategy.old <- future::plan("list")
[17:26:34.830]                   options(future.plan = NULL)
[17:26:34.830]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:34.830]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:34.830]                 }
[17:26:34.830]                 ...future.workdir <- getwd()
[17:26:34.830]             }
[17:26:34.830]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:34.830]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:34.830]         }
[17:26:34.830]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:34.830]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:34.830]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:34.830]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:34.830]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:34.830]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:34.830]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:34.830]             base::names(...future.oldOptions))
[17:26:34.830]     }
[17:26:34.830]     if (FALSE) {
[17:26:34.830]     }
[17:26:34.830]     else {
[17:26:34.830]         if (TRUE) {
[17:26:34.830]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:34.830]                 open = "w")
[17:26:34.830]         }
[17:26:34.830]         else {
[17:26:34.830]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:34.830]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:34.830]         }
[17:26:34.830]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:34.830]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:34.830]             base::sink(type = "output", split = FALSE)
[17:26:34.830]             base::close(...future.stdout)
[17:26:34.830]         }, add = TRUE)
[17:26:34.830]     }
[17:26:34.830]     ...future.frame <- base::sys.nframe()
[17:26:34.830]     ...future.conditions <- base::list()
[17:26:34.830]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:34.830]     if (FALSE) {
[17:26:34.830]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:34.830]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:34.830]     }
[17:26:34.830]     ...future.result <- base::tryCatch({
[17:26:34.830]         base::withCallingHandlers({
[17:26:34.830]             ...future.value <- base::withVisible(base::local(1))
[17:26:34.830]             future::FutureResult(value = ...future.value$value, 
[17:26:34.830]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:34.830]                   ...future.rng), globalenv = if (FALSE) 
[17:26:34.830]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:34.830]                     ...future.globalenv.names))
[17:26:34.830]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:34.830]         }, condition = base::local({
[17:26:34.830]             c <- base::c
[17:26:34.830]             inherits <- base::inherits
[17:26:34.830]             invokeRestart <- base::invokeRestart
[17:26:34.830]             length <- base::length
[17:26:34.830]             list <- base::list
[17:26:34.830]             seq.int <- base::seq.int
[17:26:34.830]             signalCondition <- base::signalCondition
[17:26:34.830]             sys.calls <- base::sys.calls
[17:26:34.830]             `[[` <- base::`[[`
[17:26:34.830]             `+` <- base::`+`
[17:26:34.830]             `<<-` <- base::`<<-`
[17:26:34.830]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:34.830]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:34.830]                   3L)]
[17:26:34.830]             }
[17:26:34.830]             function(cond) {
[17:26:34.830]                 is_error <- inherits(cond, "error")
[17:26:34.830]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:34.830]                   NULL)
[17:26:34.830]                 if (is_error) {
[17:26:34.830]                   sessionInformation <- function() {
[17:26:34.830]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:34.830]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:34.830]                       search = base::search(), system = base::Sys.info())
[17:26:34.830]                   }
[17:26:34.830]                   ...future.conditions[[length(...future.conditions) + 
[17:26:34.830]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:34.830]                     cond$call), session = sessionInformation(), 
[17:26:34.830]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:34.830]                   signalCondition(cond)
[17:26:34.830]                 }
[17:26:34.830]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:34.830]                 "immediateCondition"))) {
[17:26:34.830]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:34.830]                   ...future.conditions[[length(...future.conditions) + 
[17:26:34.830]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:34.830]                   if (TRUE && !signal) {
[17:26:34.830]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.830]                     {
[17:26:34.830]                       inherits <- base::inherits
[17:26:34.830]                       invokeRestart <- base::invokeRestart
[17:26:34.830]                       is.null <- base::is.null
[17:26:34.830]                       muffled <- FALSE
[17:26:34.830]                       if (inherits(cond, "message")) {
[17:26:34.830]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:34.830]                         if (muffled) 
[17:26:34.830]                           invokeRestart("muffleMessage")
[17:26:34.830]                       }
[17:26:34.830]                       else if (inherits(cond, "warning")) {
[17:26:34.830]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:34.830]                         if (muffled) 
[17:26:34.830]                           invokeRestart("muffleWarning")
[17:26:34.830]                       }
[17:26:34.830]                       else if (inherits(cond, "condition")) {
[17:26:34.830]                         if (!is.null(pattern)) {
[17:26:34.830]                           computeRestarts <- base::computeRestarts
[17:26:34.830]                           grepl <- base::grepl
[17:26:34.830]                           restarts <- computeRestarts(cond)
[17:26:34.830]                           for (restart in restarts) {
[17:26:34.830]                             name <- restart$name
[17:26:34.830]                             if (is.null(name)) 
[17:26:34.830]                               next
[17:26:34.830]                             if (!grepl(pattern, name)) 
[17:26:34.830]                               next
[17:26:34.830]                             invokeRestart(restart)
[17:26:34.830]                             muffled <- TRUE
[17:26:34.830]                             break
[17:26:34.830]                           }
[17:26:34.830]                         }
[17:26:34.830]                       }
[17:26:34.830]                       invisible(muffled)
[17:26:34.830]                     }
[17:26:34.830]                     muffleCondition(cond, pattern = "^muffle")
[17:26:34.830]                   }
[17:26:34.830]                 }
[17:26:34.830]                 else {
[17:26:34.830]                   if (TRUE) {
[17:26:34.830]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.830]                     {
[17:26:34.830]                       inherits <- base::inherits
[17:26:34.830]                       invokeRestart <- base::invokeRestart
[17:26:34.830]                       is.null <- base::is.null
[17:26:34.830]                       muffled <- FALSE
[17:26:34.830]                       if (inherits(cond, "message")) {
[17:26:34.830]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:34.830]                         if (muffled) 
[17:26:34.830]                           invokeRestart("muffleMessage")
[17:26:34.830]                       }
[17:26:34.830]                       else if (inherits(cond, "warning")) {
[17:26:34.830]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:34.830]                         if (muffled) 
[17:26:34.830]                           invokeRestart("muffleWarning")
[17:26:34.830]                       }
[17:26:34.830]                       else if (inherits(cond, "condition")) {
[17:26:34.830]                         if (!is.null(pattern)) {
[17:26:34.830]                           computeRestarts <- base::computeRestarts
[17:26:34.830]                           grepl <- base::grepl
[17:26:34.830]                           restarts <- computeRestarts(cond)
[17:26:34.830]                           for (restart in restarts) {
[17:26:34.830]                             name <- restart$name
[17:26:34.830]                             if (is.null(name)) 
[17:26:34.830]                               next
[17:26:34.830]                             if (!grepl(pattern, name)) 
[17:26:34.830]                               next
[17:26:34.830]                             invokeRestart(restart)
[17:26:34.830]                             muffled <- TRUE
[17:26:34.830]                             break
[17:26:34.830]                           }
[17:26:34.830]                         }
[17:26:34.830]                       }
[17:26:34.830]                       invisible(muffled)
[17:26:34.830]                     }
[17:26:34.830]                     muffleCondition(cond, pattern = "^muffle")
[17:26:34.830]                   }
[17:26:34.830]                 }
[17:26:34.830]             }
[17:26:34.830]         }))
[17:26:34.830]     }, error = function(ex) {
[17:26:34.830]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:34.830]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:34.830]                 ...future.rng), started = ...future.startTime, 
[17:26:34.830]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:34.830]             version = "1.8"), class = "FutureResult")
[17:26:34.830]     }, finally = {
[17:26:34.830]         if (!identical(...future.workdir, getwd())) 
[17:26:34.830]             setwd(...future.workdir)
[17:26:34.830]         {
[17:26:34.830]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:34.830]                 ...future.oldOptions$nwarnings <- NULL
[17:26:34.830]             }
[17:26:34.830]             base::options(...future.oldOptions)
[17:26:34.830]             if (.Platform$OS.type == "windows") {
[17:26:34.830]                 old_names <- names(...future.oldEnvVars)
[17:26:34.830]                 envs <- base::Sys.getenv()
[17:26:34.830]                 names <- names(envs)
[17:26:34.830]                 common <- intersect(names, old_names)
[17:26:34.830]                 added <- setdiff(names, old_names)
[17:26:34.830]                 removed <- setdiff(old_names, names)
[17:26:34.830]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:34.830]                   envs[common]]
[17:26:34.830]                 NAMES <- toupper(changed)
[17:26:34.830]                 args <- list()
[17:26:34.830]                 for (kk in seq_along(NAMES)) {
[17:26:34.830]                   name <- changed[[kk]]
[17:26:34.830]                   NAME <- NAMES[[kk]]
[17:26:34.830]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.830]                     next
[17:26:34.830]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:34.830]                 }
[17:26:34.830]                 NAMES <- toupper(added)
[17:26:34.830]                 for (kk in seq_along(NAMES)) {
[17:26:34.830]                   name <- added[[kk]]
[17:26:34.830]                   NAME <- NAMES[[kk]]
[17:26:34.830]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.830]                     next
[17:26:34.830]                   args[[name]] <- ""
[17:26:34.830]                 }
[17:26:34.830]                 NAMES <- toupper(removed)
[17:26:34.830]                 for (kk in seq_along(NAMES)) {
[17:26:34.830]                   name <- removed[[kk]]
[17:26:34.830]                   NAME <- NAMES[[kk]]
[17:26:34.830]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.830]                     next
[17:26:34.830]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:34.830]                 }
[17:26:34.830]                 if (length(args) > 0) 
[17:26:34.830]                   base::do.call(base::Sys.setenv, args = args)
[17:26:34.830]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:34.830]             }
[17:26:34.830]             else {
[17:26:34.830]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:34.830]             }
[17:26:34.830]             {
[17:26:34.830]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:34.830]                   0L) {
[17:26:34.830]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:34.830]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:34.830]                   base::options(opts)
[17:26:34.830]                 }
[17:26:34.830]                 {
[17:26:34.830]                   {
[17:26:34.830]                     NULL
[17:26:34.830]                     RNGkind("Mersenne-Twister")
[17:26:34.830]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:34.830]                       inherits = FALSE)
[17:26:34.830]                   }
[17:26:34.830]                   options(future.plan = NULL)
[17:26:34.830]                   if (is.na(NA_character_)) 
[17:26:34.830]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:34.830]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:34.830]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:34.830]                     .init = FALSE)
[17:26:34.830]                 }
[17:26:34.830]             }
[17:26:34.830]         }
[17:26:34.830]     })
[17:26:34.830]     if (TRUE) {
[17:26:34.830]         base::sink(type = "output", split = FALSE)
[17:26:34.830]         if (TRUE) {
[17:26:34.830]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:34.830]         }
[17:26:34.830]         else {
[17:26:34.830]             ...future.result["stdout"] <- base::list(NULL)
[17:26:34.830]         }
[17:26:34.830]         base::close(...future.stdout)
[17:26:34.830]         ...future.stdout <- NULL
[17:26:34.830]     }
[17:26:34.830]     ...future.result$conditions <- ...future.conditions
[17:26:34.830]     ...future.result$finished <- base::Sys.time()
[17:26:34.830]     ...future.result
[17:26:34.830] }
[17:26:34.834] plan(): Setting new future strategy stack:
[17:26:34.834] List of future strategies:
[17:26:34.834] 1. sequential:
[17:26:34.834]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:34.834]    - tweaked: FALSE
[17:26:34.834]    - call: NULL
[17:26:34.834] plan(): nbrOfWorkers() = 1
[17:26:34.835] plan(): Setting new future strategy stack:
[17:26:34.836] List of future strategies:
[17:26:34.836] 1. sequential:
[17:26:34.836]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:34.836]    - tweaked: FALSE
[17:26:34.836]    - call: plan(strategy)
[17:26:34.836] plan(): nbrOfWorkers() = 1
[17:26:34.837] SequentialFuture started (and completed)
[17:26:34.837] - Launch lazy future ... done
[17:26:34.837] run() for 'SequentialFuture' ... done
d = 1
** Nested future assignments
[17:26:34.837] getGlobalsAndPackages() ...
[17:26:34.838] Searching for globals...
[17:26:34.842] - globals found: [5] '{', '<-', '%<-%', '%->%', '+'
[17:26:34.842] Searching for globals ... DONE
[17:26:34.842] Resolving globals: FALSE
[17:26:34.843] 
[17:26:34.843] - packages: [1] 'future'
[17:26:34.843] getGlobalsAndPackages() ... DONE
[17:26:34.843] run() for 'Future' ...
[17:26:34.844] - state: 'created'
[17:26:34.844] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:34.844] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:34.844] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:34.845]   - Field: 'label'
[17:26:34.845]   - Field: 'local'
[17:26:34.845]   - Field: 'owner'
[17:26:34.845]   - Field: 'envir'
[17:26:34.845]   - Field: 'packages'
[17:26:34.846]   - Field: 'gc'
[17:26:34.846]   - Field: 'conditions'
[17:26:34.846]   - Field: 'expr'
[17:26:34.846]   - Field: 'uuid'
[17:26:34.846]   - Field: 'seed'
[17:26:34.846]   - Field: 'version'
[17:26:34.847]   - Field: 'result'
[17:26:34.847]   - Field: 'asynchronous'
[17:26:34.847]   - Field: 'calls'
[17:26:34.847]   - Field: 'globals'
[17:26:34.847]   - Field: 'stdout'
[17:26:34.847]   - Field: 'earlySignal'
[17:26:34.848]   - Field: 'lazy'
[17:26:34.848]   - Field: 'state'
[17:26:34.848] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:34.848] - Launch lazy future ...
[17:26:34.848] Packages needed by the future expression (n = 1): 'future'
[17:26:34.848] Packages needed by future strategies (n = 0): <none>
[17:26:34.849] {
[17:26:34.849]     {
[17:26:34.849]         {
[17:26:34.849]             ...future.startTime <- base::Sys.time()
[17:26:34.849]             {
[17:26:34.849]                 {
[17:26:34.849]                   {
[17:26:34.849]                     {
[17:26:34.849]                       base::local({
[17:26:34.849]                         has_future <- base::requireNamespace("future", 
[17:26:34.849]                           quietly = TRUE)
[17:26:34.849]                         if (has_future) {
[17:26:34.849]                           ns <- base::getNamespace("future")
[17:26:34.849]                           version <- ns[[".package"]][["version"]]
[17:26:34.849]                           if (is.null(version)) 
[17:26:34.849]                             version <- utils::packageVersion("future")
[17:26:34.849]                         }
[17:26:34.849]                         else {
[17:26:34.849]                           version <- NULL
[17:26:34.849]                         }
[17:26:34.849]                         if (!has_future || version < "1.8.0") {
[17:26:34.849]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:34.849]                             "", base::R.version$version.string), 
[17:26:34.849]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:34.849]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:34.849]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:34.849]                               "release", "version")], collapse = " "), 
[17:26:34.849]                             hostname = base::Sys.info()[["nodename"]])
[17:26:34.849]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:34.849]                             info)
[17:26:34.849]                           info <- base::paste(info, collapse = "; ")
[17:26:34.849]                           if (!has_future) {
[17:26:34.849]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:34.849]                               info)
[17:26:34.849]                           }
[17:26:34.849]                           else {
[17:26:34.849]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:34.849]                               info, version)
[17:26:34.849]                           }
[17:26:34.849]                           base::stop(msg)
[17:26:34.849]                         }
[17:26:34.849]                       })
[17:26:34.849]                     }
[17:26:34.849]                     base::local({
[17:26:34.849]                       for (pkg in "future") {
[17:26:34.849]                         base::loadNamespace(pkg)
[17:26:34.849]                         base::library(pkg, character.only = TRUE)
[17:26:34.849]                       }
[17:26:34.849]                     })
[17:26:34.849]                   }
[17:26:34.849]                   ...future.strategy.old <- future::plan("list")
[17:26:34.849]                   options(future.plan = NULL)
[17:26:34.849]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:34.849]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:34.849]                 }
[17:26:34.849]                 ...future.workdir <- getwd()
[17:26:34.849]             }
[17:26:34.849]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:34.849]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:34.849]         }
[17:26:34.849]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:34.849]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:34.849]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:34.849]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:34.849]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:34.849]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:34.849]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:34.849]             base::names(...future.oldOptions))
[17:26:34.849]     }
[17:26:34.849]     if (FALSE) {
[17:26:34.849]     }
[17:26:34.849]     else {
[17:26:34.849]         if (TRUE) {
[17:26:34.849]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:34.849]                 open = "w")
[17:26:34.849]         }
[17:26:34.849]         else {
[17:26:34.849]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:34.849]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:34.849]         }
[17:26:34.849]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:34.849]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:34.849]             base::sink(type = "output", split = FALSE)
[17:26:34.849]             base::close(...future.stdout)
[17:26:34.849]         }, add = TRUE)
[17:26:34.849]     }
[17:26:34.849]     ...future.frame <- base::sys.nframe()
[17:26:34.849]     ...future.conditions <- base::list()
[17:26:34.849]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:34.849]     if (FALSE) {
[17:26:34.849]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:34.849]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:34.849]     }
[17:26:34.849]     ...future.result <- base::tryCatch({
[17:26:34.849]         base::withCallingHandlers({
[17:26:34.849]             ...future.value <- base::withVisible(base::local({
[17:26:34.849]                 b <- 1
[17:26:34.849]                 c %<-% 2
[17:26:34.849]                 d <- 3
[17:26:34.849]                 4 %->% e
[17:26:34.849]                 b + c + d + e
[17:26:34.849]             }))
[17:26:34.849]             future::FutureResult(value = ...future.value$value, 
[17:26:34.849]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:34.849]                   ...future.rng), globalenv = if (FALSE) 
[17:26:34.849]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:34.849]                     ...future.globalenv.names))
[17:26:34.849]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:34.849]         }, condition = base::local({
[17:26:34.849]             c <- base::c
[17:26:34.849]             inherits <- base::inherits
[17:26:34.849]             invokeRestart <- base::invokeRestart
[17:26:34.849]             length <- base::length
[17:26:34.849]             list <- base::list
[17:26:34.849]             seq.int <- base::seq.int
[17:26:34.849]             signalCondition <- base::signalCondition
[17:26:34.849]             sys.calls <- base::sys.calls
[17:26:34.849]             `[[` <- base::`[[`
[17:26:34.849]             `+` <- base::`+`
[17:26:34.849]             `<<-` <- base::`<<-`
[17:26:34.849]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:34.849]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:34.849]                   3L)]
[17:26:34.849]             }
[17:26:34.849]             function(cond) {
[17:26:34.849]                 is_error <- inherits(cond, "error")
[17:26:34.849]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:34.849]                   NULL)
[17:26:34.849]                 if (is_error) {
[17:26:34.849]                   sessionInformation <- function() {
[17:26:34.849]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:34.849]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:34.849]                       search = base::search(), system = base::Sys.info())
[17:26:34.849]                   }
[17:26:34.849]                   ...future.conditions[[length(...future.conditions) + 
[17:26:34.849]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:34.849]                     cond$call), session = sessionInformation(), 
[17:26:34.849]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:34.849]                   signalCondition(cond)
[17:26:34.849]                 }
[17:26:34.849]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:34.849]                 "immediateCondition"))) {
[17:26:34.849]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:34.849]                   ...future.conditions[[length(...future.conditions) + 
[17:26:34.849]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:34.849]                   if (TRUE && !signal) {
[17:26:34.849]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.849]                     {
[17:26:34.849]                       inherits <- base::inherits
[17:26:34.849]                       invokeRestart <- base::invokeRestart
[17:26:34.849]                       is.null <- base::is.null
[17:26:34.849]                       muffled <- FALSE
[17:26:34.849]                       if (inherits(cond, "message")) {
[17:26:34.849]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:34.849]                         if (muffled) 
[17:26:34.849]                           invokeRestart("muffleMessage")
[17:26:34.849]                       }
[17:26:34.849]                       else if (inherits(cond, "warning")) {
[17:26:34.849]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:34.849]                         if (muffled) 
[17:26:34.849]                           invokeRestart("muffleWarning")
[17:26:34.849]                       }
[17:26:34.849]                       else if (inherits(cond, "condition")) {
[17:26:34.849]                         if (!is.null(pattern)) {
[17:26:34.849]                           computeRestarts <- base::computeRestarts
[17:26:34.849]                           grepl <- base::grepl
[17:26:34.849]                           restarts <- computeRestarts(cond)
[17:26:34.849]                           for (restart in restarts) {
[17:26:34.849]                             name <- restart$name
[17:26:34.849]                             if (is.null(name)) 
[17:26:34.849]                               next
[17:26:34.849]                             if (!grepl(pattern, name)) 
[17:26:34.849]                               next
[17:26:34.849]                             invokeRestart(restart)
[17:26:34.849]                             muffled <- TRUE
[17:26:34.849]                             break
[17:26:34.849]                           }
[17:26:34.849]                         }
[17:26:34.849]                       }
[17:26:34.849]                       invisible(muffled)
[17:26:34.849]                     }
[17:26:34.849]                     muffleCondition(cond, pattern = "^muffle")
[17:26:34.849]                   }
[17:26:34.849]                 }
[17:26:34.849]                 else {
[17:26:34.849]                   if (TRUE) {
[17:26:34.849]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.849]                     {
[17:26:34.849]                       inherits <- base::inherits
[17:26:34.849]                       invokeRestart <- base::invokeRestart
[17:26:34.849]                       is.null <- base::is.null
[17:26:34.849]                       muffled <- FALSE
[17:26:34.849]                       if (inherits(cond, "message")) {
[17:26:34.849]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:34.849]                         if (muffled) 
[17:26:34.849]                           invokeRestart("muffleMessage")
[17:26:34.849]                       }
[17:26:34.849]                       else if (inherits(cond, "warning")) {
[17:26:34.849]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:34.849]                         if (muffled) 
[17:26:34.849]                           invokeRestart("muffleWarning")
[17:26:34.849]                       }
[17:26:34.849]                       else if (inherits(cond, "condition")) {
[17:26:34.849]                         if (!is.null(pattern)) {
[17:26:34.849]                           computeRestarts <- base::computeRestarts
[17:26:34.849]                           grepl <- base::grepl
[17:26:34.849]                           restarts <- computeRestarts(cond)
[17:26:34.849]                           for (restart in restarts) {
[17:26:34.849]                             name <- restart$name
[17:26:34.849]                             if (is.null(name)) 
[17:26:34.849]                               next
[17:26:34.849]                             if (!grepl(pattern, name)) 
[17:26:34.849]                               next
[17:26:34.849]                             invokeRestart(restart)
[17:26:34.849]                             muffled <- TRUE
[17:26:34.849]                             break
[17:26:34.849]                           }
[17:26:34.849]                         }
[17:26:34.849]                       }
[17:26:34.849]                       invisible(muffled)
[17:26:34.849]                     }
[17:26:34.849]                     muffleCondition(cond, pattern = "^muffle")
[17:26:34.849]                   }
[17:26:34.849]                 }
[17:26:34.849]             }
[17:26:34.849]         }))
[17:26:34.849]     }, error = function(ex) {
[17:26:34.849]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:34.849]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:34.849]                 ...future.rng), started = ...future.startTime, 
[17:26:34.849]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:34.849]             version = "1.8"), class = "FutureResult")
[17:26:34.849]     }, finally = {
[17:26:34.849]         if (!identical(...future.workdir, getwd())) 
[17:26:34.849]             setwd(...future.workdir)
[17:26:34.849]         {
[17:26:34.849]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:34.849]                 ...future.oldOptions$nwarnings <- NULL
[17:26:34.849]             }
[17:26:34.849]             base::options(...future.oldOptions)
[17:26:34.849]             if (.Platform$OS.type == "windows") {
[17:26:34.849]                 old_names <- names(...future.oldEnvVars)
[17:26:34.849]                 envs <- base::Sys.getenv()
[17:26:34.849]                 names <- names(envs)
[17:26:34.849]                 common <- intersect(names, old_names)
[17:26:34.849]                 added <- setdiff(names, old_names)
[17:26:34.849]                 removed <- setdiff(old_names, names)
[17:26:34.849]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:34.849]                   envs[common]]
[17:26:34.849]                 NAMES <- toupper(changed)
[17:26:34.849]                 args <- list()
[17:26:34.849]                 for (kk in seq_along(NAMES)) {
[17:26:34.849]                   name <- changed[[kk]]
[17:26:34.849]                   NAME <- NAMES[[kk]]
[17:26:34.849]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.849]                     next
[17:26:34.849]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:34.849]                 }
[17:26:34.849]                 NAMES <- toupper(added)
[17:26:34.849]                 for (kk in seq_along(NAMES)) {
[17:26:34.849]                   name <- added[[kk]]
[17:26:34.849]                   NAME <- NAMES[[kk]]
[17:26:34.849]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.849]                     next
[17:26:34.849]                   args[[name]] <- ""
[17:26:34.849]                 }
[17:26:34.849]                 NAMES <- toupper(removed)
[17:26:34.849]                 for (kk in seq_along(NAMES)) {
[17:26:34.849]                   name <- removed[[kk]]
[17:26:34.849]                   NAME <- NAMES[[kk]]
[17:26:34.849]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.849]                     next
[17:26:34.849]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:34.849]                 }
[17:26:34.849]                 if (length(args) > 0) 
[17:26:34.849]                   base::do.call(base::Sys.setenv, args = args)
[17:26:34.849]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:34.849]             }
[17:26:34.849]             else {
[17:26:34.849]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:34.849]             }
[17:26:34.849]             {
[17:26:34.849]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:34.849]                   0L) {
[17:26:34.849]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:34.849]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:34.849]                   base::options(opts)
[17:26:34.849]                 }
[17:26:34.849]                 {
[17:26:34.849]                   {
[17:26:34.849]                     NULL
[17:26:34.849]                     RNGkind("Mersenne-Twister")
[17:26:34.849]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:34.849]                       inherits = FALSE)
[17:26:34.849]                   }
[17:26:34.849]                   options(future.plan = NULL)
[17:26:34.849]                   if (is.na(NA_character_)) 
[17:26:34.849]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:34.849]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:34.849]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:34.849]                     .init = FALSE)
[17:26:34.849]                 }
[17:26:34.849]             }
[17:26:34.849]         }
[17:26:34.849]     })
[17:26:34.849]     if (TRUE) {
[17:26:34.849]         base::sink(type = "output", split = FALSE)
[17:26:34.849]         if (TRUE) {
[17:26:34.849]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:34.849]         }
[17:26:34.849]         else {
[17:26:34.849]             ...future.result["stdout"] <- base::list(NULL)
[17:26:34.849]         }
[17:26:34.849]         base::close(...future.stdout)
[17:26:34.849]         ...future.stdout <- NULL
[17:26:34.849]     }
[17:26:34.849]     ...future.result$conditions <- ...future.conditions
[17:26:34.849]     ...future.result$finished <- base::Sys.time()
[17:26:34.849]     ...future.result
[17:26:34.849] }
[17:26:34.853] plan(): Setting new future strategy stack:
[17:26:34.854] List of future strategies:
[17:26:34.854] 1. sequential:
[17:26:34.854]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:34.854]    - tweaked: FALSE
[17:26:34.854]    - call: NULL
[17:26:34.854] plan(): nbrOfWorkers() = 1
[17:26:34.902] plan(): Setting new future strategy stack:
[17:26:34.902] List of future strategies:
[17:26:34.902] 1. sequential:
[17:26:34.902]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:34.902]    - tweaked: FALSE
[17:26:34.902]    - call: plan(strategy)
[17:26:34.902] plan(): nbrOfWorkers() = 1
[17:26:34.903] SequentialFuture started (and completed)
[17:26:34.903] signalConditions() ...
[17:26:34.903]  - include = 'immediateCondition'
[17:26:34.903]  - exclude = 
[17:26:34.903]  - resignal = FALSE
[17:26:34.903]  - Number of conditions: 88
[17:26:34.904] signalConditions() ... done
[17:26:34.904] - Launch lazy future ... done
[17:26:34.904] run() for 'SequentialFuture' ... done
[17:26:34.904] signalConditions() ...
[17:26:34.905]  - include = 'immediateCondition'
[17:26:34.905]  - exclude = 
[17:26:34.905]  - resignal = FALSE
[17:26:34.905]  - Number of conditions: 88
[17:26:34.906] signalConditions() ... done
[17:26:34.906] Future state: 'finished'
[17:26:34.906] signalConditions() ...
[17:26:34.907]  - include = 'condition'
[17:26:34.907]  - exclude = 'immediateCondition'
[17:26:34.907]  - resignal = TRUE
[17:26:34.907]  - Number of conditions: 88
[17:26:34.907]  - Condition #1: 'simpleMessage', 'message', 'condition'
[17:26:34.856] getGlobalsAndPackages() ...
[17:26:34.908]  - Condition #2: 'simpleMessage', 'message', 'condition'
[17:26:34.856] Searching for globals...
[17:26:34.908]  - Condition #3: 'simpleMessage', 'message', 'condition'
[17:26:34.872] 
[17:26:34.908]  - Condition #4: 'simpleMessage', 'message', 'condition'
[17:26:34.872] Searching for globals ... DONE
[17:26:34.908]  - Condition #5: 'simpleMessage', 'message', 'condition'
[17:26:34.872] - globals: [0] <none>
[17:26:34.908]  - Condition #6: 'simpleMessage', 'message', 'condition'
[17:26:34.872] getGlobalsAndPackages() ... DONE
[17:26:34.909]  - Condition #7: 'simpleMessage', 'message', 'condition'
[17:26:34.873] run() for 'Future' ...
[17:26:34.909]  - Condition #8: 'simpleMessage', 'message', 'condition'
[17:26:34.873] - state: 'created'
[17:26:34.909]  - Condition #9: 'simpleMessage', 'message', 'condition'
[17:26:34.873] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:34.909]  - Condition #10: 'simpleMessage', 'message', 'condition'
[17:26:34.873] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:34.909]  - Condition #11: 'simpleMessage', 'message', 'condition'
[17:26:34.874] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:34.910]  - Condition #12: 'simpleMessage', 'message', 'condition'
[17:26:34.874]   - Field: 'label'
[17:26:34.910]  - Condition #13: 'simpleMessage', 'message', 'condition'
[17:26:34.874]   - Field: 'local'
[17:26:34.910]  - Condition #14: 'simpleMessage', 'message', 'condition'
[17:26:34.874]   - Field: 'owner'
[17:26:34.910]  - Condition #15: 'simpleMessage', 'message', 'condition'
[17:26:34.874]   - Field: 'envir'
[17:26:34.910]  - Condition #16: 'simpleMessage', 'message', 'condition'
[17:26:34.875]   - Field: 'packages'
[17:26:34.911]  - Condition #17: 'simpleMessage', 'message', 'condition'
[17:26:34.875]   - Field: 'gc'
[17:26:34.911]  - Condition #18: 'simpleMessage', 'message', 'condition'
[17:26:34.875]   - Field: 'conditions'
[17:26:34.911]  - Condition #19: 'simpleMessage', 'message', 'condition'
[17:26:34.875]   - Field: 'expr'
[17:26:34.911]  - Condition #20: 'simpleMessage', 'message', 'condition'
[17:26:34.875]   - Field: 'uuid'
[17:26:34.911]  - Condition #21: 'simpleMessage', 'message', 'condition'
[17:26:34.875]   - Field: 'seed'
[17:26:34.912]  - Condition #22: 'simpleMessage', 'message', 'condition'
[17:26:34.876]   - Field: 'version'
[17:26:34.912]  - Condition #23: 'simpleMessage', 'message', 'condition'
[17:26:34.876]   - Field: 'result'
[17:26:34.912]  - Condition #24: 'simpleMessage', 'message', 'condition'
[17:26:34.876]   - Field: 'asynchronous'
[17:26:34.912]  - Condition #25: 'simpleMessage', 'message', 'condition'
[17:26:34.876]   - Field: 'calls'
[17:26:34.913]  - Condition #26: 'simpleMessage', 'message', 'condition'
[17:26:34.876]   - Field: 'globals'
[17:26:34.913]  - Condition #27: 'simpleMessage', 'message', 'condition'
[17:26:34.877]   - Field: 'stdout'
[17:26:34.913]  - Condition #28: 'simpleMessage', 'message', 'condition'
[17:26:34.877]   - Field: 'earlySignal'
[17:26:34.913]  - Condition #29: 'simpleMessage', 'message', 'condition'
[17:26:34.877]   - Field: 'lazy'
[17:26:34.913]  - Condition #30: 'simpleMessage', 'message', 'condition'
[17:26:34.877]   - Field: 'state'
[17:26:34.914]  - Condition #31: 'simpleMessage', 'message', 'condition'
[17:26:34.877] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:34.914]  - Condition #32: 'simpleMessage', 'message', 'condition'
[17:26:34.878] - Launch lazy future ...
[17:26:34.914]  - Condition #33: 'simpleMessage', 'message', 'condition'
[17:26:34.878] Packages needed by the future expression (n = 0): <none>
[17:26:34.914]  - Condition #34: 'simpleMessage', 'message', 'condition'
[17:26:34.878] Packages needed by future strategies (n = 0): <none>
[17:26:34.914]  - Condition #35: 'simpleMessage', 'message', 'condition'
[17:26:34.879] {
[17:26:34.879]     {
[17:26:34.879]         {
[17:26:34.879]             ...future.startTime <- base::Sys.time()
[17:26:34.879]             {
[17:26:34.879]                 {
[17:26:34.879]                   {
[17:26:34.879]                     base::local({
[17:26:34.879]                       has_future <- base::requireNamespace("future", 
[17:26:34.879]                         quietly = TRUE)
[17:26:34.879]                       if (has_future) {
[17:26:34.879]                         ns <- base::getNamespace("future")
[17:26:34.879]                         version <- ns[[".package"]][["version"]]
[17:26:34.879]                         if (is.null(version)) 
[17:26:34.879]                           version <- utils::packageVersion("future")
[17:26:34.879]                       }
[17:26:34.879]                       else {
[17:26:34.879]                         version <- NULL
[17:26:34.879]                       }
[17:26:34.879]                       if (!has_future || version < "1.8.0") {
[17:26:34.879]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:34.879]                           "", base::R.version$version.string), 
[17:26:34.879]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:34.879]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:34.879]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:34.879]                             "release", "version")], collapse = " "), 
[17:26:34.879]                           hostname = base::Sys.info()[["nodename"]])
[17:26:34.879]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:34.879]                           info)
[17:26:34.879]                         info <- base::paste(info, collapse = "; ")
[17:26:34.879]                         if (!has_future) {
[17:26:34.879]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:34.879]                             info)
[17:26:34.879]                         }
[17:26:34.879]                         else {
[17:26:34.879]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:34.879]                             info, version)
[17:26:34.879]                         }
[17:26:34.879]                         base::stop(msg)
[17:26:34.879]                       }
[17:26:34.879]                     })
[17:26:34.879]                   }
[17:26:34.879]                   ...future.strategy.old <- future::plan("list")
[17:26:34.879]                   options(future.plan = NULL)
[17:26:34.879]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:34.879]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:34.879]                 }
[17:26:34.879]                 ...future.workdir <- getwd()
[17:26:34.879]             }
[17:26:34.879]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:34.879]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:34.879]         }
[17:26:34.879]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:34.879]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:34.879]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:34.879]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:34.879]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:34.879]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:34.879]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:34.879]             base::names(...future.oldOptions))
[17:26:34.879]     }
[17:26:34.879]     if (FALSE) {
[17:26:34.879]     }
[17:26:34.879]     else {
[17:26:34.879]         if (TRUE) {
[17:26:34.879]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:34.879]                 open = "w")
[17:26:34.879]         }
[17:26:34.879]         else {
[17:26:34.879]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:34.879]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:34.879]         }
[17:26:34.879]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:34.879]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:34.879]             base::sink(type = "output", split = FALSE)
[17:26:34.879]             base::close(...future.stdout)
[17:26:34.879]         }, add = TRUE)
[17:26:34.879]     }
[17:26:34.879]     ...future.frame <- base::sys.nframe()
[17:26:34.879]     ...future.conditions <- base::list()
[17:26:34.879]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:34.879]     if (FALSE) {
[17:26:34.879]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:34.879]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:34.879]     }
[17:26:34.879]     ...future.result <- base::tryCatch({
[17:26:34.879]         base::withCallingHandlers({
[17:26:34.879]             ...future.value <- base::withVisible(base::local(2))
[17:26:34.879]             future::FutureResult(value = ...future.value$value, 
[17:26:34.879]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:34.879]                   ...future.rng), globalenv = if (FALSE) 
[17:26:34.879]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:34.879]                     ...future.globalenv.names))
[17:26:34.879]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:34.879]         }, condition = base::local({
[17:26:34.879]             c <- base::c
[17:26:34.879]             inherits <- base::inherits
[17:26:34.879]             invokeRestart <- base::invokeRestart
[17:26:34.879]             length <- base::length
[17:26:34.879]             list <- base::list
[17:26:34.879]             seq.int <- base::seq.int
[17:26:34.879]             signalCondition <- base::signalCondition
[17:26:34.879]             sys.calls <- base::sys.calls
[17:26:34.879]             `[[` <- base::`[[`
[17:26:34.879]             `+` <- base::`+`
[17:26:34.879]             `<<-` <- base::`<<-`
[17:26:34.879]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:34.879]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:34.879]                   3L)]
[17:26:34.879]             }
[17:26:34.879]             function(cond) {
[17:26:34.879]                 is_error <- inherits(cond, "error")
[17:26:34.879]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:34.879]                   NULL)
[17:26:34.879]                 if (is_error) {
[17:26:34.879]                   sessionInformation <- function() {
[17:26:34.879]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:34.879]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:34.879]                       search = base::search(), system = base::Sys.info())
[17:26:34.879]                   }
[17:26:34.879]                   ...future.conditions[[length(...future.conditions) + 
[17:26:34.879]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:34.879]                     cond$call), session = sessionInformation(), 
[17:26:34.879]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:34.879]                   signalCondition(cond)
[17:26:34.879]                 }
[17:26:34.879]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:34.879]                 "immediateCondition"))) {
[17:26:34.879]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:34.879]                   ...future.conditions[[length(...future.conditions) + 
[17:26:34.879]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:34.879]                   if (TRUE && !signal) {
[17:26:34.879]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.879]                     {
[17:26:34.879]                       inherits <- base::inherits
[17:26:34.879]                       invokeRestart <- base::invokeRestart
[17:26:34.879]                       is.null <- base::is.null
[17:26:34.879]                       muffled <- FALSE
[17:26:34.879]                       if (inherits(cond, "message")) {
[17:26:34.879]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:34.879]                         if (muffled) 
[17:26:34.879]                           invokeRestart("muffleMessage")
[17:26:34.879]                       }
[17:26:34.879]                       else if (inherits(cond, "warning")) {
[17:26:34.879]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:34.879]                         if (muffled) 
[17:26:34.879]                           invokeRestart("muffleWarning")
[17:26:34.879]                       }
[17:26:34.879]                       else if (inherits(cond, "condition")) {
[17:26:34.879]                         if (!is.null(pattern)) {
[17:26:34.879]                           computeRestarts <- base::computeRestarts
[17:26:34.879]                           grepl <- base::grepl
[17:26:34.879]                           restarts <- computeRestarts(cond)
[17:26:34.879]                           for (restart in restarts) {
[17:26:34.879]                             name <- restart$name
[17:26:34.879]                             if (is.null(name)) 
[17:26:34.879]                               next
[17:26:34.879]                             if (!grepl(pattern, name)) 
[17:26:34.879]                               next
[17:26:34.879]                             invokeRestart(restart)
[17:26:34.879]                             muffled <- TRUE
[17:26:34.879]                             break
[17:26:34.879]                           }
[17:26:34.879]                         }
[17:26:34.879]                       }
[17:26:34.879]                       invisible(muffled)
[17:26:34.879]                     }
[17:26:34.879]                     muffleCondition(cond, pattern = "^muffle")
[17:26:34.879]                   }
[17:26:34.879]                 }
[17:26:34.879]                 else {
[17:26:34.879]                   if (TRUE) {
[17:26:34.879]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.879]                     {
[17:26:34.879]                       inherits <- base::inherits
[17:26:34.879]                       invokeRestart <- base::invokeRestart
[17:26:34.879]                       is.null <- base::is.null
[17:26:34.879]                       muffled <- FALSE
[17:26:34.879]                       if (inherits(cond, "message")) {
[17:26:34.879]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:34.879]                         if (muffled) 
[17:26:34.879]                           invokeRestart("muffleMessage")
[17:26:34.879]                       }
[17:26:34.879]                       else if (inherits(cond, "warning")) {
[17:26:34.879]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:34.879]                         if (muffled) 
[17:26:34.879]                           invokeRestart("muffleWarning")
[17:26:34.879]                       }
[17:26:34.879]                       else if (inherits(cond, "condition")) {
[17:26:34.879]                         if (!is.null(pattern)) {
[17:26:34.879]                           computeRestarts <- base::computeRestarts
[17:26:34.879]                           grepl <- base::grepl
[17:26:34.879]                           restarts <- computeRestarts(cond)
[17:26:34.879]                           for (restart in restarts) {
[17:26:34.879]                             name <- restart$name
[17:26:34.879]                             if (is.null(name)) 
[17:26:34.879]                               next
[17:26:34.879]                             if (!grepl(pattern, name)) 
[17:26:34.879]                               next
[17:26:34.879]                             invokeRestart(restart)
[17:26:34.879]                             muffled <- TRUE
[17:26:34.879]                             break
[17:26:34.879]                           }
[17:26:34.879]                         }
[17:26:34.879]                       }
[17:26:34.879]                       invisible(muffled)
[17:26:34.879]                     }
[17:26:34.879]                     muffleCondition(cond, pattern = "^muffle")
[17:26:34.879]                   }
[17:26:34.879]                 }
[17:26:34.879]             }
[17:26:34.879]         }))
[17:26:34.879]     }, error = function(ex) {
[17:26:34.879]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:34.879]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:34.879]                 ...future.rng), started = ...future.startTime, 
[17:26:34.879]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:34.879]             version = "1.8"), class = "FutureResult")
[17:26:34.879]     }, finally = {
[17:26:34.879]         if (!identical(...future.workdir, getwd())) 
[17:26:34.879]             setwd(...future.workdir)
[17:26:34.879]         {
[17:26:34.879]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:34.879]                 ...future.oldOptions$nwarnings <- NULL
[17:26:34.879]             }
[17:26:34.879]             base::options(...future.oldOptions)
[17:26:34.879]             if (.Platform$OS.type == "windows") {
[17:26:34.879]                 old_names <- names(...future.oldEnvVars)
[17:26:34.879]                 envs <- base::Sys.getenv()
[17:26:34.879]                 names <- names(envs)
[17:26:34.879]                 common <- intersect(names, old_names)
[17:26:34.879]                 added <- setdiff(names, old_names)
[17:26:34.879]                 removed <- setdiff(old_names, names)
[17:26:34.879]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:34.879]                   envs[common]]
[17:26:34.879]                 NAMES <- toupper(changed)
[17:26:34.879]                 args <- list()
[17:26:34.879]                 for (kk in seq_along(NAMES)) {
[17:26:34.879]                   name <- changed[[kk]]
[17:26:34.879]                   NAME <- NAMES[[kk]]
[17:26:34.879]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.879]                     next
[17:26:34.879]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:34.879]                 }
[17:26:34.879]                 NAMES <- toupper(added)
[17:26:34.879]                 for (kk in seq_along(NAMES)) {
[17:26:34.879]                   name <- added[[kk]]
[17:26:34.879]                   NAME <- NAMES[[kk]]
[17:26:34.879]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.879]                     next
[17:26:34.879]                   args[[name]] <- ""
[17:26:34.879]                 }
[17:26:34.879]                 NAMES <- toupper(removed)
[17:26:34.879]                 for (kk in seq_along(NAMES)) {
[17:26:34.879]                   name <- removed[[kk]]
[17:26:34.879]                   NAME <- NAMES[[kk]]
[17:26:34.879]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.879]                     next
[17:26:34.879]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:34.879]                 }
[17:26:34.879]                 if (length(args) > 0) 
[17:26:34.879]                   base::do.call(base::Sys.setenv, args = args)
[17:26:34.879]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:34.879]             }
[17:26:34.879]             else {
[17:26:34.879]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:34.879]             }
[17:26:34.879]             {
[17:26:34.879]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:34.879]                   0L) {
[17:26:34.879]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:34.879]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:34.879]                   base::options(opts)
[17:26:34.879]                 }
[17:26:34.879]                 {
[17:26:34.879]                   {
[17:26:34.879]                     NULL
[17:26:34.879]                     RNGkind("Mersenne-Twister")
[17:26:34.879]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:34.879]                       inherits = FALSE)
[17:26:34.879]                   }
[17:26:34.879]                   options(future.plan = NULL)
[17:26:34.879]                   if (is.na(NA_character_)) 
[17:26:34.879]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:34.879]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:34.879]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:34.879]                     .init = FALSE)
[17:26:34.879]                 }
[17:26:34.879]             }
[17:26:34.879]         }
[17:26:34.879]     })
[17:26:34.879]     if (TRUE) {
[17:26:34.879]         base::sink(type = "output", split = FALSE)
[17:26:34.879]         if (TRUE) {
[17:26:34.879]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:34.879]         }
[17:26:34.879]         else {
[17:26:34.879]             ...future.result["stdout"] <- base::list(NULL)
[17:26:34.879]         }
[17:26:34.879]         base::close(...future.stdout)
[17:26:34.879]         ...future.stdout <- NULL
[17:26:34.879]     }
[17:26:34.879]     ...future.result$conditions <- ...future.conditions
[17:26:34.879]     ...future.result$finished <- base::Sys.time()
[17:26:34.879]     ...future.result
[17:26:34.879] }
[17:26:34.915]  - Condition #36: 'simpleMessage', 'message', 'condition'
[17:26:34.882] plan(): Setting new future strategy stack:
[17:26:34.915]  - Condition #37: 'simpleMessage', 'message', 'condition'
[17:26:34.882] List of future strategies:
[17:26:34.882] 1. sequential:
[17:26:34.882]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:34.882]    - tweaked: FALSE
[17:26:34.882]    - call: NULL
[17:26:34.915]  - Condition #38: 'simpleMessage', 'message', 'condition'
[17:26:34.883] plan(): nbrOfWorkers() = 1
[17:26:34.915]  - Condition #39: 'simpleMessage', 'message', 'condition'
[17:26:34.884] plan(): Setting new future strategy stack:
[17:26:34.916]  - Condition #40: 'simpleMessage', 'message', 'condition'
[17:26:34.884] List of future strategies:
[17:26:34.884] 1. sequential:
[17:26:34.884]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:34.884]    - tweaked: FALSE
[17:26:34.884]    - call: NULL
[17:26:34.916]  - Condition #41: 'simpleMessage', 'message', 'condition'
[17:26:34.885] plan(): nbrOfWorkers() = 1
[17:26:34.916]  - Condition #42: 'simpleMessage', 'message', 'condition'
[17:26:34.885] SequentialFuture started (and completed)
[17:26:34.916]  - Condition #43: 'simpleMessage', 'message', 'condition'
[17:26:34.885] - Launch lazy future ... done
[17:26:34.916]  - Condition #44: 'simpleMessage', 'message', 'condition'
[17:26:34.886] run() for 'SequentialFuture' ... done
[17:26:34.917]  - Condition #45: 'simpleMessage', 'message', 'condition'
[17:26:34.886] getGlobalsAndPackages() ...
[17:26:34.917]  - Condition #46: 'simpleMessage', 'message', 'condition'
[17:26:34.886] Searching for globals...
[17:26:34.917]  - Condition #47: 'simpleMessage', 'message', 'condition'
[17:26:34.887] 
[17:26:34.917]  - Condition #48: 'simpleMessage', 'message', 'condition'
[17:26:34.887] Searching for globals ... DONE
[17:26:34.917]  - Condition #49: 'simpleMessage', 'message', 'condition'
[17:26:34.887] - globals: [0] <none>
[17:26:34.918]  - Condition #50: 'simpleMessage', 'message', 'condition'
[17:26:34.887] getGlobalsAndPackages() ... DONE
[17:26:34.918]  - Condition #51: 'simpleMessage', 'message', 'condition'
[17:26:34.887] run() for 'Future' ...
[17:26:34.918]  - Condition #52: 'simpleMessage', 'message', 'condition'
[17:26:34.888] - state: 'created'
[17:26:34.918]  - Condition #53: 'simpleMessage', 'message', 'condition'
[17:26:34.888] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:34.918]  - Condition #54: 'simpleMessage', 'message', 'condition'
[17:26:34.888] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:34.919]  - Condition #55: 'simpleMessage', 'message', 'condition'
[17:26:34.889] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:34.919]  - Condition #56: 'simpleMessage', 'message', 'condition'
[17:26:34.889]   - Field: 'label'
[17:26:34.919]  - Condition #57: 'simpleMessage', 'message', 'condition'
[17:26:34.889]   - Field: 'local'
[17:26:34.919]  - Condition #58: 'simpleMessage', 'message', 'condition'
[17:26:34.889]   - Field: 'owner'
[17:26:34.919]  - Condition #59: 'simpleMessage', 'message', 'condition'
[17:26:34.889]   - Field: 'envir'
[17:26:34.920]  - Condition #60: 'simpleMessage', 'message', 'condition'
[17:26:34.889]   - Field: 'packages'
[17:26:34.920]  - Condition #61: 'simpleMessage', 'message', 'condition'
[17:26:34.890]   - Field: 'gc'
[17:26:34.920]  - Condition #62: 'simpleMessage', 'message', 'condition'
[17:26:34.890]   - Field: 'conditions'
[17:26:34.920]  - Condition #63: 'simpleMessage', 'message', 'condition'
[17:26:34.890]   - Field: 'expr'
[17:26:34.920]  - Condition #64: 'simpleMessage', 'message', 'condition'
[17:26:34.890]   - Field: 'uuid'
[17:26:34.921]  - Condition #65: 'simpleMessage', 'message', 'condition'
[17:26:34.890]   - Field: 'seed'
[17:26:34.921]  - Condition #66: 'simpleMessage', 'message', 'condition'
[17:26:34.891]   - Field: 'version'
[17:26:34.921]  - Condition #67: 'simpleMessage', 'message', 'condition'
[17:26:34.891]   - Field: 'result'
[17:26:34.921]  - Condition #68: 'simpleMessage', 'message', 'condition'
[17:26:34.891]   - Field: 'asynchronous'
[17:26:34.922]  - Condition #69: 'simpleMessage', 'message', 'condition'
[17:26:34.891]   - Field: 'calls'
[17:26:34.922]  - Condition #70: 'simpleMessage', 'message', 'condition'
[17:26:34.891]   - Field: 'globals'
[17:26:34.922]  - Condition #71: 'simpleMessage', 'message', 'condition'
[17:26:34.892]   - Field: 'stdout'
[17:26:34.922]  - Condition #72: 'simpleMessage', 'message', 'condition'
[17:26:34.892]   - Field: 'earlySignal'
[17:26:34.922]  - Condition #73: 'simpleMessage', 'message', 'condition'
[17:26:34.892]   - Field: 'lazy'
[17:26:34.923]  - Condition #74: 'simpleMessage', 'message', 'condition'
[17:26:34.892]   - Field: 'state'
[17:26:34.923]  - Condition #75: 'simpleMessage', 'message', 'condition'
[17:26:34.892] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:34.923]  - Condition #76: 'simpleMessage', 'message', 'condition'
[17:26:34.892] - Launch lazy future ...
[17:26:34.923]  - Condition #77: 'simpleMessage', 'message', 'condition'
[17:26:34.893] Packages needed by the future expression (n = 0): <none>
[17:26:34.923]  - Condition #78: 'simpleMessage', 'message', 'condition'
[17:26:34.893] Packages needed by future strategies (n = 0): <none>
[17:26:34.924]  - Condition #79: 'simpleMessage', 'message', 'condition'
[17:26:34.893] {
[17:26:34.893]     {
[17:26:34.893]         {
[17:26:34.893]             ...future.startTime <- base::Sys.time()
[17:26:34.893]             {
[17:26:34.893]                 {
[17:26:34.893]                   {
[17:26:34.893]                     base::local({
[17:26:34.893]                       has_future <- base::requireNamespace("future", 
[17:26:34.893]                         quietly = TRUE)
[17:26:34.893]                       if (has_future) {
[17:26:34.893]                         ns <- base::getNamespace("future")
[17:26:34.893]                         version <- ns[[".package"]][["version"]]
[17:26:34.893]                         if (is.null(version)) 
[17:26:34.893]                           version <- utils::packageVersion("future")
[17:26:34.893]                       }
[17:26:34.893]                       else {
[17:26:34.893]                         version <- NULL
[17:26:34.893]                       }
[17:26:34.893]                       if (!has_future || version < "1.8.0") {
[17:26:34.893]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:34.893]                           "", base::R.version$version.string), 
[17:26:34.893]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:34.893]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:34.893]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:34.893]                             "release", "version")], collapse = " "), 
[17:26:34.893]                           hostname = base::Sys.info()[["nodename"]])
[17:26:34.893]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:34.893]                           info)
[17:26:34.893]                         info <- base::paste(info, collapse = "; ")
[17:26:34.893]                         if (!has_future) {
[17:26:34.893]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:34.893]                             info)
[17:26:34.893]                         }
[17:26:34.893]                         else {
[17:26:34.893]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:34.893]                             info, version)
[17:26:34.893]                         }
[17:26:34.893]                         base::stop(msg)
[17:26:34.893]                       }
[17:26:34.893]                     })
[17:26:34.893]                   }
[17:26:34.893]                   ...future.strategy.old <- future::plan("list")
[17:26:34.893]                   options(future.plan = NULL)
[17:26:34.893]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:34.893]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:34.893]                 }
[17:26:34.893]                 ...future.workdir <- getwd()
[17:26:34.893]             }
[17:26:34.893]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:34.893]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:34.893]         }
[17:26:34.893]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:34.893]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:34.893]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:34.893]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:34.893]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:34.893]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:34.893]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:34.893]             base::names(...future.oldOptions))
[17:26:34.893]     }
[17:26:34.893]     if (FALSE) {
[17:26:34.893]     }
[17:26:34.893]     else {
[17:26:34.893]         if (TRUE) {
[17:26:34.893]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:34.893]                 open = "w")
[17:26:34.893]         }
[17:26:34.893]         else {
[17:26:34.893]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:34.893]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:34.893]         }
[17:26:34.893]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:34.893]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:34.893]             base::sink(type = "output", split = FALSE)
[17:26:34.893]             base::close(...future.stdout)
[17:26:34.893]         }, add = TRUE)
[17:26:34.893]     }
[17:26:34.893]     ...future.frame <- base::sys.nframe()
[17:26:34.893]     ...future.conditions <- base::list()
[17:26:34.893]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:34.893]     if (FALSE) {
[17:26:34.893]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:34.893]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:34.893]     }
[17:26:34.893]     ...future.result <- base::tryCatch({
[17:26:34.893]         base::withCallingHandlers({
[17:26:34.893]             ...future.value <- base::withVisible(base::local(4))
[17:26:34.893]             future::FutureResult(value = ...future.value$value, 
[17:26:34.893]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:34.893]                   ...future.rng), globalenv = if (FALSE) 
[17:26:34.893]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:34.893]                     ...future.globalenv.names))
[17:26:34.893]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:34.893]         }, condition = base::local({
[17:26:34.893]             c <- base::c
[17:26:34.893]             inherits <- base::inherits
[17:26:34.893]             invokeRestart <- base::invokeRestart
[17:26:34.893]             length <- base::length
[17:26:34.893]             list <- base::list
[17:26:34.893]             seq.int <- base::seq.int
[17:26:34.893]             signalCondition <- base::signalCondition
[17:26:34.893]             sys.calls <- base::sys.calls
[17:26:34.893]             `[[` <- base::`[[`
[17:26:34.893]             `+` <- base::`+`
[17:26:34.893]             `<<-` <- base::`<<-`
[17:26:34.893]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:34.893]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:34.893]                   3L)]
[17:26:34.893]             }
[17:26:34.893]             function(cond) {
[17:26:34.893]                 is_error <- inherits(cond, "error")
[17:26:34.893]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:34.893]                   NULL)
[17:26:34.893]                 if (is_error) {
[17:26:34.893]                   sessionInformation <- function() {
[17:26:34.893]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:34.893]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:34.893]                       search = base::search(), system = base::Sys.info())
[17:26:34.893]                   }
[17:26:34.893]                   ...future.conditions[[length(...future.conditions) + 
[17:26:34.893]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:34.893]                     cond$call), session = sessionInformation(), 
[17:26:34.893]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:34.893]                   signalCondition(cond)
[17:26:34.893]                 }
[17:26:34.893]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:34.893]                 "immediateCondition"))) {
[17:26:34.893]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:34.893]                   ...future.conditions[[length(...future.conditions) + 
[17:26:34.893]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:34.893]                   if (TRUE && !signal) {
[17:26:34.893]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.893]                     {
[17:26:34.893]                       inherits <- base::inherits
[17:26:34.893]                       invokeRestart <- base::invokeRestart
[17:26:34.893]                       is.null <- base::is.null
[17:26:34.893]                       muffled <- FALSE
[17:26:34.893]                       if (inherits(cond, "message")) {
[17:26:34.893]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:34.893]                         if (muffled) 
[17:26:34.893]                           invokeRestart("muffleMessage")
[17:26:34.893]                       }
[17:26:34.893]                       else if (inherits(cond, "warning")) {
[17:26:34.893]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:34.893]                         if (muffled) 
[17:26:34.893]                           invokeRestart("muffleWarning")
[17:26:34.893]                       }
[17:26:34.893]                       else if (inherits(cond, "condition")) {
[17:26:34.893]                         if (!is.null(pattern)) {
[17:26:34.893]                           computeRestarts <- base::computeRestarts
[17:26:34.893]                           grepl <- base::grepl
[17:26:34.893]                           restarts <- computeRestarts(cond)
[17:26:34.893]                           for (restart in restarts) {
[17:26:34.893]                             name <- restart$name
[17:26:34.893]                             if (is.null(name)) 
[17:26:34.893]                               next
[17:26:34.893]                             if (!grepl(pattern, name)) 
[17:26:34.893]                               next
[17:26:34.893]                             invokeRestart(restart)
[17:26:34.893]                             muffled <- TRUE
[17:26:34.893]                             break
[17:26:34.893]                           }
[17:26:34.893]                         }
[17:26:34.893]                       }
[17:26:34.893]                       invisible(muffled)
[17:26:34.893]                     }
[17:26:34.893]                     muffleCondition(cond, pattern = "^muffle")
[17:26:34.893]                   }
[17:26:34.893]                 }
[17:26:34.893]                 else {
[17:26:34.893]                   if (TRUE) {
[17:26:34.893]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.893]                     {
[17:26:34.893]                       inherits <- base::inherits
[17:26:34.893]                       invokeRestart <- base::invokeRestart
[17:26:34.893]                       is.null <- base::is.null
[17:26:34.893]                       muffled <- FALSE
[17:26:34.893]                       if (inherits(cond, "message")) {
[17:26:34.893]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:34.893]                         if (muffled) 
[17:26:34.893]                           invokeRestart("muffleMessage")
[17:26:34.893]                       }
[17:26:34.893]                       else if (inherits(cond, "warning")) {
[17:26:34.893]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:34.893]                         if (muffled) 
[17:26:34.893]                           invokeRestart("muffleWarning")
[17:26:34.893]                       }
[17:26:34.893]                       else if (inherits(cond, "condition")) {
[17:26:34.893]                         if (!is.null(pattern)) {
[17:26:34.893]                           computeRestarts <- base::computeRestarts
[17:26:34.893]                           grepl <- base::grepl
[17:26:34.893]                           restarts <- computeRestarts(cond)
[17:26:34.893]                           for (restart in restarts) {
[17:26:34.893]                             name <- restart$name
[17:26:34.893]                             if (is.null(name)) 
[17:26:34.893]                               next
[17:26:34.893]                             if (!grepl(pattern, name)) 
[17:26:34.893]                               next
[17:26:34.893]                             invokeRestart(restart)
[17:26:34.893]                             muffled <- TRUE
[17:26:34.893]                             break
[17:26:34.893]                           }
[17:26:34.893]                         }
[17:26:34.893]                       }
[17:26:34.893]                       invisible(muffled)
[17:26:34.893]                     }
[17:26:34.893]                     muffleCondition(cond, pattern = "^muffle")
[17:26:34.893]                   }
[17:26:34.893]                 }
[17:26:34.893]             }
[17:26:34.893]         }))
[17:26:34.893]     }, error = function(ex) {
[17:26:34.893]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:34.893]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:34.893]                 ...future.rng), started = ...future.startTime, 
[17:26:34.893]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:34.893]             version = "1.8"), class = "FutureResult")
[17:26:34.893]     }, finally = {
[17:26:34.893]         if (!identical(...future.workdir, getwd())) 
[17:26:34.893]             setwd(...future.workdir)
[17:26:34.893]         {
[17:26:34.893]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:34.893]                 ...future.oldOptions$nwarnings <- NULL
[17:26:34.893]             }
[17:26:34.893]             base::options(...future.oldOptions)
[17:26:34.893]             if (.Platform$OS.type == "windows") {
[17:26:34.893]                 old_names <- names(...future.oldEnvVars)
[17:26:34.893]                 envs <- base::Sys.getenv()
[17:26:34.893]                 names <- names(envs)
[17:26:34.893]                 common <- intersect(names, old_names)
[17:26:34.893]                 added <- setdiff(names, old_names)
[17:26:34.893]                 removed <- setdiff(old_names, names)
[17:26:34.893]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:34.893]                   envs[common]]
[17:26:34.893]                 NAMES <- toupper(changed)
[17:26:34.893]                 args <- list()
[17:26:34.893]                 for (kk in seq_along(NAMES)) {
[17:26:34.893]                   name <- changed[[kk]]
[17:26:34.893]                   NAME <- NAMES[[kk]]
[17:26:34.893]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.893]                     next
[17:26:34.893]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:34.893]                 }
[17:26:34.893]                 NAMES <- toupper(added)
[17:26:34.893]                 for (kk in seq_along(NAMES)) {
[17:26:34.893]                   name <- added[[kk]]
[17:26:34.893]                   NAME <- NAMES[[kk]]
[17:26:34.893]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.893]                     next
[17:26:34.893]                   args[[name]] <- ""
[17:26:34.893]                 }
[17:26:34.893]                 NAMES <- toupper(removed)
[17:26:34.893]                 for (kk in seq_along(NAMES)) {
[17:26:34.893]                   name <- removed[[kk]]
[17:26:34.893]                   NAME <- NAMES[[kk]]
[17:26:34.893]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.893]                     next
[17:26:34.893]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:34.893]                 }
[17:26:34.893]                 if (length(args) > 0) 
[17:26:34.893]                   base::do.call(base::Sys.setenv, args = args)
[17:26:34.893]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:34.893]             }
[17:26:34.893]             else {
[17:26:34.893]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:34.893]             }
[17:26:34.893]             {
[17:26:34.893]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:34.893]                   0L) {
[17:26:34.893]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:34.893]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:34.893]                   base::options(opts)
[17:26:34.893]                 }
[17:26:34.893]                 {
[17:26:34.893]                   {
[17:26:34.893]                     NULL
[17:26:34.893]                     RNGkind("Mersenne-Twister")
[17:26:34.893]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:34.893]                       inherits = FALSE)
[17:26:34.893]                   }
[17:26:34.893]                   options(future.plan = NULL)
[17:26:34.893]                   if (is.na(NA_character_)) 
[17:26:34.893]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:34.893]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:34.893]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:34.893]                     .init = FALSE)
[17:26:34.893]                 }
[17:26:34.893]             }
[17:26:34.893]         }
[17:26:34.893]     })
[17:26:34.893]     if (TRUE) {
[17:26:34.893]         base::sink(type = "output", split = FALSE)
[17:26:34.893]         if (TRUE) {
[17:26:34.893]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:34.893]         }
[17:26:34.893]         else {
[17:26:34.893]             ...future.result["stdout"] <- base::list(NULL)
[17:26:34.893]         }
[17:26:34.893]         base::close(...future.stdout)
[17:26:34.893]         ...future.stdout <- NULL
[17:26:34.893]     }
[17:26:34.893]     ...future.result$conditions <- ...future.conditions
[17:26:34.893]     ...future.result$finished <- base::Sys.time()
[17:26:34.893]     ...future.result
[17:26:34.893] }
[17:26:34.924]  - Condition #80: 'simpleMessage', 'message', 'condition'
[17:26:34.897] plan(): Setting new future strategy stack:
[17:26:34.924]  - Condition #81: 'simpleMessage', 'message', 'condition'
[17:26:34.897] List of future strategies:
[17:26:34.897] 1. sequential:
[17:26:34.897]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:34.897]    - tweaked: FALSE
[17:26:34.897]    - call: NULL
[17:26:34.925]  - Condition #82: 'simpleMessage', 'message', 'condition'
[17:26:34.898] plan(): nbrOfWorkers() = 1
[17:26:34.925]  - Condition #83: 'simpleMessage', 'message', 'condition'
[17:26:34.899] plan(): Setting new future strategy stack:
[17:26:34.925]  - Condition #84: 'simpleMessage', 'message', 'condition'
[17:26:34.899] List of future strategies:
[17:26:34.899] 1. sequential:
[17:26:34.899]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:34.899]    - tweaked: FALSE
[17:26:34.899]    - call: NULL
[17:26:34.925]  - Condition #85: 'simpleMessage', 'message', 'condition'
[17:26:34.900] plan(): nbrOfWorkers() = 1
[17:26:34.925]  - Condition #86: 'simpleMessage', 'message', 'condition'
[17:26:34.900] SequentialFuture started (and completed)
[17:26:34.926]  - Condition #87: 'simpleMessage', 'message', 'condition'
[17:26:34.900] - Launch lazy future ... done
[17:26:34.926]  - Condition #88: 'simpleMessage', 'message', 'condition'
[17:26:34.901] run() for 'SequentialFuture' ... done
[17:26:34.926] signalConditions() ... done
a = 10
[17:26:34.926] getGlobalsAndPackages() ...
[17:26:34.927] Searching for globals...
[17:26:34.928] - globals found: [3] '{', '+', 'a'
[17:26:34.928] Searching for globals ... DONE
[17:26:34.928] Resolving globals: FALSE
[17:26:34.928] The total size of the 1 globals is 56 bytes (56 bytes)
[17:26:34.929] The total size of the 1 globals exported for future expression ('{; a + 1; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'a' (56 bytes of class 'numeric')
[17:26:34.929] - globals: [1] 'a'
[17:26:34.929] 
[17:26:34.929] getGlobalsAndPackages() ... DONE
[17:26:34.930] run() for 'Future' ...
[17:26:34.930] - state: 'created'
[17:26:34.930] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:34.930] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:34.931] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:34.931]   - Field: 'label'
[17:26:34.931]   - Field: 'local'
[17:26:34.931]   - Field: 'owner'
[17:26:34.931]   - Field: 'envir'
[17:26:34.931]   - Field: 'packages'
[17:26:34.932]   - Field: 'gc'
[17:26:34.932]   - Field: 'conditions'
[17:26:34.932]   - Field: 'expr'
[17:26:34.932]   - Field: 'uuid'
[17:26:34.933]   - Field: 'seed'
[17:26:34.933]   - Field: 'version'
[17:26:34.933]   - Field: 'result'
[17:26:34.934]   - Field: 'asynchronous'
[17:26:34.934]   - Field: 'calls'
[17:26:34.934]   - Field: 'globals'
[17:26:34.934]   - Field: 'stdout'
[17:26:34.934]   - Field: 'earlySignal'
[17:26:34.935]   - Field: 'lazy'
[17:26:34.935]   - Field: 'state'
[17:26:34.935] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:34.935] - Launch lazy future ...
[17:26:34.935] Packages needed by the future expression (n = 0): <none>
[17:26:34.935] Packages needed by future strategies (n = 0): <none>
[17:26:34.936] {
[17:26:34.936]     {
[17:26:34.936]         {
[17:26:34.936]             ...future.startTime <- base::Sys.time()
[17:26:34.936]             {
[17:26:34.936]                 {
[17:26:34.936]                   {
[17:26:34.936]                     base::local({
[17:26:34.936]                       has_future <- base::requireNamespace("future", 
[17:26:34.936]                         quietly = TRUE)
[17:26:34.936]                       if (has_future) {
[17:26:34.936]                         ns <- base::getNamespace("future")
[17:26:34.936]                         version <- ns[[".package"]][["version"]]
[17:26:34.936]                         if (is.null(version)) 
[17:26:34.936]                           version <- utils::packageVersion("future")
[17:26:34.936]                       }
[17:26:34.936]                       else {
[17:26:34.936]                         version <- NULL
[17:26:34.936]                       }
[17:26:34.936]                       if (!has_future || version < "1.8.0") {
[17:26:34.936]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:34.936]                           "", base::R.version$version.string), 
[17:26:34.936]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:34.936]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:34.936]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:34.936]                             "release", "version")], collapse = " "), 
[17:26:34.936]                           hostname = base::Sys.info()[["nodename"]])
[17:26:34.936]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:34.936]                           info)
[17:26:34.936]                         info <- base::paste(info, collapse = "; ")
[17:26:34.936]                         if (!has_future) {
[17:26:34.936]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:34.936]                             info)
[17:26:34.936]                         }
[17:26:34.936]                         else {
[17:26:34.936]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:34.936]                             info, version)
[17:26:34.936]                         }
[17:26:34.936]                         base::stop(msg)
[17:26:34.936]                       }
[17:26:34.936]                     })
[17:26:34.936]                   }
[17:26:34.936]                   ...future.strategy.old <- future::plan("list")
[17:26:34.936]                   options(future.plan = NULL)
[17:26:34.936]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:34.936]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:34.936]                 }
[17:26:34.936]                 ...future.workdir <- getwd()
[17:26:34.936]             }
[17:26:34.936]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:34.936]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:34.936]         }
[17:26:34.936]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:34.936]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:34.936]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:34.936]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:34.936]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:34.936]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:34.936]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:34.936]             base::names(...future.oldOptions))
[17:26:34.936]     }
[17:26:34.936]     if (FALSE) {
[17:26:34.936]     }
[17:26:34.936]     else {
[17:26:34.936]         if (TRUE) {
[17:26:34.936]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:34.936]                 open = "w")
[17:26:34.936]         }
[17:26:34.936]         else {
[17:26:34.936]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:34.936]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:34.936]         }
[17:26:34.936]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:34.936]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:34.936]             base::sink(type = "output", split = FALSE)
[17:26:34.936]             base::close(...future.stdout)
[17:26:34.936]         }, add = TRUE)
[17:26:34.936]     }
[17:26:34.936]     ...future.frame <- base::sys.nframe()
[17:26:34.936]     ...future.conditions <- base::list()
[17:26:34.936]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:34.936]     if (FALSE) {
[17:26:34.936]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:34.936]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:34.936]     }
[17:26:34.936]     ...future.result <- base::tryCatch({
[17:26:34.936]         base::withCallingHandlers({
[17:26:34.936]             ...future.value <- base::withVisible(base::local({
[17:26:34.936]                 a + 1
[17:26:34.936]             }))
[17:26:34.936]             future::FutureResult(value = ...future.value$value, 
[17:26:34.936]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:34.936]                   ...future.rng), globalenv = if (FALSE) 
[17:26:34.936]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:34.936]                     ...future.globalenv.names))
[17:26:34.936]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:34.936]         }, condition = base::local({
[17:26:34.936]             c <- base::c
[17:26:34.936]             inherits <- base::inherits
[17:26:34.936]             invokeRestart <- base::invokeRestart
[17:26:34.936]             length <- base::length
[17:26:34.936]             list <- base::list
[17:26:34.936]             seq.int <- base::seq.int
[17:26:34.936]             signalCondition <- base::signalCondition
[17:26:34.936]             sys.calls <- base::sys.calls
[17:26:34.936]             `[[` <- base::`[[`
[17:26:34.936]             `+` <- base::`+`
[17:26:34.936]             `<<-` <- base::`<<-`
[17:26:34.936]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:34.936]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:34.936]                   3L)]
[17:26:34.936]             }
[17:26:34.936]             function(cond) {
[17:26:34.936]                 is_error <- inherits(cond, "error")
[17:26:34.936]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:34.936]                   NULL)
[17:26:34.936]                 if (is_error) {
[17:26:34.936]                   sessionInformation <- function() {
[17:26:34.936]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:34.936]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:34.936]                       search = base::search(), system = base::Sys.info())
[17:26:34.936]                   }
[17:26:34.936]                   ...future.conditions[[length(...future.conditions) + 
[17:26:34.936]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:34.936]                     cond$call), session = sessionInformation(), 
[17:26:34.936]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:34.936]                   signalCondition(cond)
[17:26:34.936]                 }
[17:26:34.936]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:34.936]                 "immediateCondition"))) {
[17:26:34.936]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:34.936]                   ...future.conditions[[length(...future.conditions) + 
[17:26:34.936]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:34.936]                   if (TRUE && !signal) {
[17:26:34.936]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.936]                     {
[17:26:34.936]                       inherits <- base::inherits
[17:26:34.936]                       invokeRestart <- base::invokeRestart
[17:26:34.936]                       is.null <- base::is.null
[17:26:34.936]                       muffled <- FALSE
[17:26:34.936]                       if (inherits(cond, "message")) {
[17:26:34.936]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:34.936]                         if (muffled) 
[17:26:34.936]                           invokeRestart("muffleMessage")
[17:26:34.936]                       }
[17:26:34.936]                       else if (inherits(cond, "warning")) {
[17:26:34.936]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:34.936]                         if (muffled) 
[17:26:34.936]                           invokeRestart("muffleWarning")
[17:26:34.936]                       }
[17:26:34.936]                       else if (inherits(cond, "condition")) {
[17:26:34.936]                         if (!is.null(pattern)) {
[17:26:34.936]                           computeRestarts <- base::computeRestarts
[17:26:34.936]                           grepl <- base::grepl
[17:26:34.936]                           restarts <- computeRestarts(cond)
[17:26:34.936]                           for (restart in restarts) {
[17:26:34.936]                             name <- restart$name
[17:26:34.936]                             if (is.null(name)) 
[17:26:34.936]                               next
[17:26:34.936]                             if (!grepl(pattern, name)) 
[17:26:34.936]                               next
[17:26:34.936]                             invokeRestart(restart)
[17:26:34.936]                             muffled <- TRUE
[17:26:34.936]                             break
[17:26:34.936]                           }
[17:26:34.936]                         }
[17:26:34.936]                       }
[17:26:34.936]                       invisible(muffled)
[17:26:34.936]                     }
[17:26:34.936]                     muffleCondition(cond, pattern = "^muffle")
[17:26:34.936]                   }
[17:26:34.936]                 }
[17:26:34.936]                 else {
[17:26:34.936]                   if (TRUE) {
[17:26:34.936]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:34.936]                     {
[17:26:34.936]                       inherits <- base::inherits
[17:26:34.936]                       invokeRestart <- base::invokeRestart
[17:26:34.936]                       is.null <- base::is.null
[17:26:34.936]                       muffled <- FALSE
[17:26:34.936]                       if (inherits(cond, "message")) {
[17:26:34.936]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:34.936]                         if (muffled) 
[17:26:34.936]                           invokeRestart("muffleMessage")
[17:26:34.936]                       }
[17:26:34.936]                       else if (inherits(cond, "warning")) {
[17:26:34.936]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:34.936]                         if (muffled) 
[17:26:34.936]                           invokeRestart("muffleWarning")
[17:26:34.936]                       }
[17:26:34.936]                       else if (inherits(cond, "condition")) {
[17:26:34.936]                         if (!is.null(pattern)) {
[17:26:34.936]                           computeRestarts <- base::computeRestarts
[17:26:34.936]                           grepl <- base::grepl
[17:26:34.936]                           restarts <- computeRestarts(cond)
[17:26:34.936]                           for (restart in restarts) {
[17:26:34.936]                             name <- restart$name
[17:26:34.936]                             if (is.null(name)) 
[17:26:34.936]                               next
[17:26:34.936]                             if (!grepl(pattern, name)) 
[17:26:34.936]                               next
[17:26:34.936]                             invokeRestart(restart)
[17:26:34.936]                             muffled <- TRUE
[17:26:34.936]                             break
[17:26:34.936]                           }
[17:26:34.936]                         }
[17:26:34.936]                       }
[17:26:34.936]                       invisible(muffled)
[17:26:34.936]                     }
[17:26:34.936]                     muffleCondition(cond, pattern = "^muffle")
[17:26:34.936]                   }
[17:26:34.936]                 }
[17:26:34.936]             }
[17:26:34.936]         }))
[17:26:34.936]     }, error = function(ex) {
[17:26:34.936]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:34.936]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:34.936]                 ...future.rng), started = ...future.startTime, 
[17:26:34.936]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:34.936]             version = "1.8"), class = "FutureResult")
[17:26:34.936]     }, finally = {
[17:26:34.936]         if (!identical(...future.workdir, getwd())) 
[17:26:34.936]             setwd(...future.workdir)
[17:26:34.936]         {
[17:26:34.936]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:34.936]                 ...future.oldOptions$nwarnings <- NULL
[17:26:34.936]             }
[17:26:34.936]             base::options(...future.oldOptions)
[17:26:34.936]             if (.Platform$OS.type == "windows") {
[17:26:34.936]                 old_names <- names(...future.oldEnvVars)
[17:26:34.936]                 envs <- base::Sys.getenv()
[17:26:34.936]                 names <- names(envs)
[17:26:34.936]                 common <- intersect(names, old_names)
[17:26:34.936]                 added <- setdiff(names, old_names)
[17:26:34.936]                 removed <- setdiff(old_names, names)
[17:26:34.936]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:34.936]                   envs[common]]
[17:26:34.936]                 NAMES <- toupper(changed)
[17:26:34.936]                 args <- list()
[17:26:34.936]                 for (kk in seq_along(NAMES)) {
[17:26:34.936]                   name <- changed[[kk]]
[17:26:34.936]                   NAME <- NAMES[[kk]]
[17:26:34.936]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.936]                     next
[17:26:34.936]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:34.936]                 }
[17:26:34.936]                 NAMES <- toupper(added)
[17:26:34.936]                 for (kk in seq_along(NAMES)) {
[17:26:34.936]                   name <- added[[kk]]
[17:26:34.936]                   NAME <- NAMES[[kk]]
[17:26:34.936]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.936]                     next
[17:26:34.936]                   args[[name]] <- ""
[17:26:34.936]                 }
[17:26:34.936]                 NAMES <- toupper(removed)
[17:26:34.936]                 for (kk in seq_along(NAMES)) {
[17:26:34.936]                   name <- removed[[kk]]
[17:26:34.936]                   NAME <- NAMES[[kk]]
[17:26:34.936]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:34.936]                     next
[17:26:34.936]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:34.936]                 }
[17:26:34.936]                 if (length(args) > 0) 
[17:26:34.936]                   base::do.call(base::Sys.setenv, args = args)
[17:26:34.936]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:34.936]             }
[17:26:34.936]             else {
[17:26:34.936]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:34.936]             }
[17:26:34.936]             {
[17:26:34.936]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:34.936]                   0L) {
[17:26:34.936]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:34.936]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:34.936]                   base::options(opts)
[17:26:34.936]                 }
[17:26:34.936]                 {
[17:26:34.936]                   {
[17:26:34.936]                     NULL
[17:26:34.936]                     RNGkind("Mersenne-Twister")
[17:26:34.936]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:34.936]                       inherits = FALSE)
[17:26:34.936]                   }
[17:26:34.936]                   options(future.plan = NULL)
[17:26:34.936]                   if (is.na(NA_character_)) 
[17:26:34.936]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:34.936]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:34.936]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:34.936]                     .init = FALSE)
[17:26:34.936]                 }
[17:26:34.936]             }
[17:26:34.936]         }
[17:26:34.936]     })
[17:26:34.936]     if (TRUE) {
[17:26:34.936]         base::sink(type = "output", split = FALSE)
[17:26:34.936]         if (TRUE) {
[17:26:34.936]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:34.936]         }
[17:26:34.936]         else {
[17:26:34.936]             ...future.result["stdout"] <- base::list(NULL)
[17:26:34.936]         }
[17:26:34.936]         base::close(...future.stdout)
[17:26:34.936]         ...future.stdout <- NULL
[17:26:34.936]     }
[17:26:34.936]     ...future.result$conditions <- ...future.conditions
[17:26:34.936]     ...future.result$finished <- base::Sys.time()
[17:26:34.936]     ...future.result
[17:26:34.936] }
[17:26:34.940] assign_globals() ...
[17:26:34.940] List of 1
[17:26:34.940]  $ a: num 10
[17:26:34.940]  - attr(*, "where")=List of 1
[17:26:34.940]   ..$ a:<environment: R_EmptyEnv> 
[17:26:34.940]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:26:34.940]  - attr(*, "resolved")= logi FALSE
[17:26:34.940]  - attr(*, "total_size")= num 56
[17:26:34.940]  - attr(*, "already-done")= logi TRUE
[17:26:34.943] - copied 'a' to environment
[17:26:34.943] assign_globals() ... done
[17:26:34.943] plan(): Setting new future strategy stack:
[17:26:34.943] List of future strategies:
[17:26:34.943] 1. sequential:
[17:26:34.943]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:34.943]    - tweaked: FALSE
[17:26:34.943]    - call: NULL
[17:26:34.944] plan(): nbrOfWorkers() = 1
[17:26:34.945] plan(): Setting new future strategy stack:
[17:26:34.945] List of future strategies:
[17:26:34.945] 1. sequential:
[17:26:34.945]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:34.945]    - tweaked: FALSE
[17:26:34.945]    - call: plan(strategy)
[17:26:34.946] plan(): nbrOfWorkers() = 1
[17:26:34.946] SequentialFuture started (and completed)
[17:26:34.946] - Launch lazy future ... done
[17:26:34.946] run() for 'SequentialFuture' ... done
b = 11
*** %<-% with 'sequential' futures ... DONE
Testing with 1 cores ... DONE
Testing with 2 cores ...
*** %<-% with 'multisession' futures ...
[17:26:34.952] plan(): Setting new future strategy stack:
[17:26:34.953] List of future strategies:
[17:26:34.953] 1. multisession:
[17:26:34.953]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:26:34.953]    - tweaked: FALSE
[17:26:34.953]    - call: plan(strategy)
[17:26:34.953] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[17:26:34.953] multisession:
[17:26:34.953] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:26:34.953] - tweaked: FALSE
[17:26:34.953] - call: plan(strategy)
[17:26:34.957] getGlobalsAndPackages() ...
[17:26:34.958] Not searching for globals
[17:26:34.958] - globals: [0] <none>
[17:26:34.958] getGlobalsAndPackages() ... DONE
[17:26:34.959] [local output] makeClusterPSOCK() ...
[17:26:34.992] [local output] Workers: [n = 2] 'localhost', 'localhost'
[17:26:34.998] [local output] Base port: 25543
[17:26:34.998] [local output] Getting setup options for 2 cluster nodes ...
[17:26:34.999] [local output]  - Node 1 of 2 ...
[17:26:34.999] [local output] localMachine=TRUE => revtunnel=FALSE

[17:26:35.000] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpicobMq/worker.rank=1.parallelly.parent=44372.ad5472536e0.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/RtmpicobMq/worker.rank=1.parallelly.parent=44372.ad5472536e0.pid\")"'
[17:26:35.433] - Possible to infer worker's PID: TRUE
[17:26:35.434] [local output] Rscript port: 25543

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

[17:26:35.436] [local output] Rscript port: 25543

[17:26:35.437] [local output] Getting setup options for 2 cluster nodes ... done
[17:26:35.437] [local output]  - Parallel setup requested for some PSOCK nodes
[17:26:35.438] [local output] Setting up PSOCK nodes in parallel
[17:26:35.438] List of 36
[17:26:35.438]  $ worker          : chr "localhost"
[17:26:35.438]   ..- attr(*, "localhost")= logi TRUE
[17:26:35.438]  $ master          : chr "localhost"
[17:26:35.438]  $ port            : int 25543
[17:26:35.438]  $ connectTimeout  : num 120
[17:26:35.438]  $ timeout         : num 120
[17:26:35.438]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[17:26:35.438]  $ homogeneous     : logi TRUE
[17:26:35.438]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=futureAssign_OP.R:44372:CRANWIN3"| __truncated__
[17:26:35.438]  $ rscript_envs    : NULL
[17:26:35.438]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpAVtqMV/RLIBS_30708245f64e7" "D:/RCompile/recent/R/library"
[17:26:35.438]  $ rscript_startup : NULL
[17:26:35.438]  $ rscript_sh      : chr "cmd"
[17:26:35.438]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:26:35.438]  $ methods         : logi TRUE
[17:26:35.438]  $ socketOptions   : chr "no-delay"
[17:26:35.438]  $ useXDR          : logi FALSE
[17:26:35.438]  $ outfile         : chr "/dev/null"
[17:26:35.438]  $ renice          : int NA
[17:26:35.438]  $ rshcmd          : NULL
[17:26:35.438]  $ user            : chr(0) 
[17:26:35.438]  $ revtunnel       : logi FALSE
[17:26:35.438]  $ rshlogfile      : NULL
[17:26:35.438]  $ rshopts         : chr(0) 
[17:26:35.438]  $ rank            : int 1
[17:26:35.438]  $ manual          : logi FALSE
[17:26:35.438]  $ dryrun          : logi FALSE
[17:26:35.438]  $ quiet           : logi FALSE
[17:26:35.438]  $ setup_strategy  : chr "parallel"
[17:26:35.438]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:26:35.438]  $ pidfile         : chr "D:/temp/RtmpicobMq/worker.rank=1.parallelly.parent=44372.ad5472536e0.pid"
[17:26:35.438]  $ rshcmd_label    : NULL
[17:26:35.438]  $ rsh_call        : NULL
[17:26:35.438]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:26:35.438]  $ localMachine    : logi TRUE
[17:26:35.438]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[17:26:35.438]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[17:26:35.438]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[17:26:35.438]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[17:26:35.438]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[17:26:35.438]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[17:26:35.438]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[17:26:35.438]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[17:26:35.438]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[17:26:35.438]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[17:26:35.438]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[17:26:35.438]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[17:26:35.438]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[17:26:35.438]  $ arguments       :List of 28
[17:26:35.438]   ..$ worker          : chr "localhost"
[17:26:35.438]   ..$ master          : NULL
[17:26:35.438]   ..$ port            : int 25543
[17:26:35.438]   ..$ connectTimeout  : num 120
[17:26:35.438]   ..$ timeout         : num 120
[17:26:35.438]   ..$ rscript         : NULL
[17:26:35.438]   ..$ homogeneous     : NULL
[17:26:35.438]   ..$ rscript_args    : NULL
[17:26:35.438]   ..$ rscript_envs    : NULL
[17:26:35.438]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpAVtqMV/RLIBS_30708245f64e7" "D:/RCompile/recent/R/library"
[17:26:35.438]   ..$ rscript_startup : NULL
[17:26:35.438]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[17:26:35.438]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:26:35.438]   ..$ methods         : logi TRUE
[17:26:35.438]   ..$ socketOptions   : chr "no-delay"
[17:26:35.438]   ..$ useXDR          : logi FALSE
[17:26:35.438]   ..$ outfile         : chr "/dev/null"
[17:26:35.438]   ..$ renice          : int NA
[17:26:35.438]   ..$ rshcmd          : NULL
[17:26:35.438]   ..$ user            : NULL
[17:26:35.438]   ..$ revtunnel       : logi NA
[17:26:35.438]   ..$ rshlogfile      : NULL
[17:26:35.438]   ..$ rshopts         : NULL
[17:26:35.438]   ..$ rank            : int 1
[17:26:35.438]   ..$ manual          : logi FALSE
[17:26:35.438]   ..$ dryrun          : logi FALSE
[17:26:35.438]   ..$ quiet           : logi FALSE
[17:26:35.438]   ..$ setup_strategy  : chr "parallel"
[17:26:35.438]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[17:26:35.459] [local output] System call to launch all workers:
[17:26:35.460] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=futureAssign_OP.R:44372:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpicobMq/worker.rank=1.parallelly.parent=44372.ad5472536e0.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpAVtqMV/RLIBS_30708245f64e7\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=25543 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[17:26:35.460] [local output] Starting PSOCK main server
[17:26:35.466] [local output] Workers launched
[17:26:35.466] [local output] Waiting for workers to connect back
[17:26:35.466]  - [local output] 0 workers out of 2 ready
[17:26:35.627]  - [local output] 0 workers out of 2 ready
[17:26:35.628]  - [local output] 1 workers out of 2 ready
[17:26:35.630]  - [local output] 1 workers out of 2 ready
[17:26:35.630]  - [local output] 2 workers out of 2 ready
[17:26:35.630] [local output] Launching of workers completed
[17:26:35.630] [local output] Collecting session information from workers
[17:26:35.631] [local output]  - Worker #1 of 2
[17:26:35.632] [local output]  - Worker #2 of 2
[17:26:35.632] [local output] makeClusterPSOCK() ... done
[17:26:35.645] Packages needed by the future expression (n = 0): <none>
[17:26:35.645] Packages needed by future strategies (n = 0): <none>
[17:26:35.646] {
[17:26:35.646]     {
[17:26:35.646]         {
[17:26:35.646]             ...future.startTime <- base::Sys.time()
[17:26:35.646]             {
[17:26:35.646]                 {
[17:26:35.646]                   {
[17:26:35.646]                     {
[17:26:35.646]                       base::local({
[17:26:35.646]                         has_future <- base::requireNamespace("future", 
[17:26:35.646]                           quietly = TRUE)
[17:26:35.646]                         if (has_future) {
[17:26:35.646]                           ns <- base::getNamespace("future")
[17:26:35.646]                           version <- ns[[".package"]][["version"]]
[17:26:35.646]                           if (is.null(version)) 
[17:26:35.646]                             version <- utils::packageVersion("future")
[17:26:35.646]                         }
[17:26:35.646]                         else {
[17:26:35.646]                           version <- NULL
[17:26:35.646]                         }
[17:26:35.646]                         if (!has_future || version < "1.8.0") {
[17:26:35.646]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:35.646]                             "", base::R.version$version.string), 
[17:26:35.646]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:35.646]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:35.646]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:35.646]                               "release", "version")], collapse = " "), 
[17:26:35.646]                             hostname = base::Sys.info()[["nodename"]])
[17:26:35.646]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:35.646]                             info)
[17:26:35.646]                           info <- base::paste(info, collapse = "; ")
[17:26:35.646]                           if (!has_future) {
[17:26:35.646]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:35.646]                               info)
[17:26:35.646]                           }
[17:26:35.646]                           else {
[17:26:35.646]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:35.646]                               info, version)
[17:26:35.646]                           }
[17:26:35.646]                           base::stop(msg)
[17:26:35.646]                         }
[17:26:35.646]                       })
[17:26:35.646]                     }
[17:26:35.646]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:35.646]                     base::options(mc.cores = 1L)
[17:26:35.646]                   }
[17:26:35.646]                   ...future.strategy.old <- future::plan("list")
[17:26:35.646]                   options(future.plan = NULL)
[17:26:35.646]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:35.646]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:35.646]                 }
[17:26:35.646]                 ...future.workdir <- getwd()
[17:26:35.646]             }
[17:26:35.646]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:35.646]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:35.646]         }
[17:26:35.646]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:35.646]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:35.646]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:35.646]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:35.646]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:35.646]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:35.646]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:35.646]             base::names(...future.oldOptions))
[17:26:35.646]     }
[17:26:35.646]     if (FALSE) {
[17:26:35.646]     }
[17:26:35.646]     else {
[17:26:35.646]         if (TRUE) {
[17:26:35.646]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:35.646]                 open = "w")
[17:26:35.646]         }
[17:26:35.646]         else {
[17:26:35.646]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:35.646]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:35.646]         }
[17:26:35.646]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:35.646]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:35.646]             base::sink(type = "output", split = FALSE)
[17:26:35.646]             base::close(...future.stdout)
[17:26:35.646]         }, add = TRUE)
[17:26:35.646]     }
[17:26:35.646]     ...future.frame <- base::sys.nframe()
[17:26:35.646]     ...future.conditions <- base::list()
[17:26:35.646]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:35.646]     if (FALSE) {
[17:26:35.646]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:35.646]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:35.646]     }
[17:26:35.646]     ...future.result <- base::tryCatch({
[17:26:35.646]         base::withCallingHandlers({
[17:26:35.646]             ...future.value <- base::withVisible(base::local({
[17:26:35.646]                 ...future.makeSendCondition <- base::local({
[17:26:35.646]                   sendCondition <- NULL
[17:26:35.646]                   function(frame = 1L) {
[17:26:35.646]                     if (is.function(sendCondition)) 
[17:26:35.646]                       return(sendCondition)
[17:26:35.646]                     ns <- getNamespace("parallel")
[17:26:35.646]                     if (exists("sendData", mode = "function", 
[17:26:35.646]                       envir = ns)) {
[17:26:35.646]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:35.646]                         envir = ns)
[17:26:35.646]                       envir <- sys.frame(frame)
[17:26:35.646]                       master <- NULL
[17:26:35.646]                       while (!identical(envir, .GlobalEnv) && 
[17:26:35.646]                         !identical(envir, emptyenv())) {
[17:26:35.646]                         if (exists("master", mode = "list", envir = envir, 
[17:26:35.646]                           inherits = FALSE)) {
[17:26:35.646]                           master <- get("master", mode = "list", 
[17:26:35.646]                             envir = envir, inherits = FALSE)
[17:26:35.646]                           if (inherits(master, c("SOCKnode", 
[17:26:35.646]                             "SOCK0node"))) {
[17:26:35.646]                             sendCondition <<- function(cond) {
[17:26:35.646]                               data <- list(type = "VALUE", value = cond, 
[17:26:35.646]                                 success = TRUE)
[17:26:35.646]                               parallel_sendData(master, data)
[17:26:35.646]                             }
[17:26:35.646]                             return(sendCondition)
[17:26:35.646]                           }
[17:26:35.646]                         }
[17:26:35.646]                         frame <- frame + 1L
[17:26:35.646]                         envir <- sys.frame(frame)
[17:26:35.646]                       }
[17:26:35.646]                     }
[17:26:35.646]                     sendCondition <<- function(cond) NULL
[17:26:35.646]                   }
[17:26:35.646]                 })
[17:26:35.646]                 withCallingHandlers({
[17:26:35.646]                   NA
[17:26:35.646]                 }, immediateCondition = function(cond) {
[17:26:35.646]                   sendCondition <- ...future.makeSendCondition()
[17:26:35.646]                   sendCondition(cond)
[17:26:35.646]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:35.646]                   {
[17:26:35.646]                     inherits <- base::inherits
[17:26:35.646]                     invokeRestart <- base::invokeRestart
[17:26:35.646]                     is.null <- base::is.null
[17:26:35.646]                     muffled <- FALSE
[17:26:35.646]                     if (inherits(cond, "message")) {
[17:26:35.646]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:35.646]                       if (muffled) 
[17:26:35.646]                         invokeRestart("muffleMessage")
[17:26:35.646]                     }
[17:26:35.646]                     else if (inherits(cond, "warning")) {
[17:26:35.646]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:35.646]                       if (muffled) 
[17:26:35.646]                         invokeRestart("muffleWarning")
[17:26:35.646]                     }
[17:26:35.646]                     else if (inherits(cond, "condition")) {
[17:26:35.646]                       if (!is.null(pattern)) {
[17:26:35.646]                         computeRestarts <- base::computeRestarts
[17:26:35.646]                         grepl <- base::grepl
[17:26:35.646]                         restarts <- computeRestarts(cond)
[17:26:35.646]                         for (restart in restarts) {
[17:26:35.646]                           name <- restart$name
[17:26:35.646]                           if (is.null(name)) 
[17:26:35.646]                             next
[17:26:35.646]                           if (!grepl(pattern, name)) 
[17:26:35.646]                             next
[17:26:35.646]                           invokeRestart(restart)
[17:26:35.646]                           muffled <- TRUE
[17:26:35.646]                           break
[17:26:35.646]                         }
[17:26:35.646]                       }
[17:26:35.646]                     }
[17:26:35.646]                     invisible(muffled)
[17:26:35.646]                   }
[17:26:35.646]                   muffleCondition(cond)
[17:26:35.646]                 })
[17:26:35.646]             }))
[17:26:35.646]             future::FutureResult(value = ...future.value$value, 
[17:26:35.646]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:35.646]                   ...future.rng), globalenv = if (FALSE) 
[17:26:35.646]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:35.646]                     ...future.globalenv.names))
[17:26:35.646]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:35.646]         }, condition = base::local({
[17:26:35.646]             c <- base::c
[17:26:35.646]             inherits <- base::inherits
[17:26:35.646]             invokeRestart <- base::invokeRestart
[17:26:35.646]             length <- base::length
[17:26:35.646]             list <- base::list
[17:26:35.646]             seq.int <- base::seq.int
[17:26:35.646]             signalCondition <- base::signalCondition
[17:26:35.646]             sys.calls <- base::sys.calls
[17:26:35.646]             `[[` <- base::`[[`
[17:26:35.646]             `+` <- base::`+`
[17:26:35.646]             `<<-` <- base::`<<-`
[17:26:35.646]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:35.646]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:35.646]                   3L)]
[17:26:35.646]             }
[17:26:35.646]             function(cond) {
[17:26:35.646]                 is_error <- inherits(cond, "error")
[17:26:35.646]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:35.646]                   NULL)
[17:26:35.646]                 if (is_error) {
[17:26:35.646]                   sessionInformation <- function() {
[17:26:35.646]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:35.646]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:35.646]                       search = base::search(), system = base::Sys.info())
[17:26:35.646]                   }
[17:26:35.646]                   ...future.conditions[[length(...future.conditions) + 
[17:26:35.646]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:35.646]                     cond$call), session = sessionInformation(), 
[17:26:35.646]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:35.646]                   signalCondition(cond)
[17:26:35.646]                 }
[17:26:35.646]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:35.646]                 "immediateCondition"))) {
[17:26:35.646]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:35.646]                   ...future.conditions[[length(...future.conditions) + 
[17:26:35.646]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:35.646]                   if (TRUE && !signal) {
[17:26:35.646]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:35.646]                     {
[17:26:35.646]                       inherits <- base::inherits
[17:26:35.646]                       invokeRestart <- base::invokeRestart
[17:26:35.646]                       is.null <- base::is.null
[17:26:35.646]                       muffled <- FALSE
[17:26:35.646]                       if (inherits(cond, "message")) {
[17:26:35.646]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:35.646]                         if (muffled) 
[17:26:35.646]                           invokeRestart("muffleMessage")
[17:26:35.646]                       }
[17:26:35.646]                       else if (inherits(cond, "warning")) {
[17:26:35.646]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:35.646]                         if (muffled) 
[17:26:35.646]                           invokeRestart("muffleWarning")
[17:26:35.646]                       }
[17:26:35.646]                       else if (inherits(cond, "condition")) {
[17:26:35.646]                         if (!is.null(pattern)) {
[17:26:35.646]                           computeRestarts <- base::computeRestarts
[17:26:35.646]                           grepl <- base::grepl
[17:26:35.646]                           restarts <- computeRestarts(cond)
[17:26:35.646]                           for (restart in restarts) {
[17:26:35.646]                             name <- restart$name
[17:26:35.646]                             if (is.null(name)) 
[17:26:35.646]                               next
[17:26:35.646]                             if (!grepl(pattern, name)) 
[17:26:35.646]                               next
[17:26:35.646]                             invokeRestart(restart)
[17:26:35.646]                             muffled <- TRUE
[17:26:35.646]                             break
[17:26:35.646]                           }
[17:26:35.646]                         }
[17:26:35.646]                       }
[17:26:35.646]                       invisible(muffled)
[17:26:35.646]                     }
[17:26:35.646]                     muffleCondition(cond, pattern = "^muffle")
[17:26:35.646]                   }
[17:26:35.646]                 }
[17:26:35.646]                 else {
[17:26:35.646]                   if (TRUE) {
[17:26:35.646]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:35.646]                     {
[17:26:35.646]                       inherits <- base::inherits
[17:26:35.646]                       invokeRestart <- base::invokeRestart
[17:26:35.646]                       is.null <- base::is.null
[17:26:35.646]                       muffled <- FALSE
[17:26:35.646]                       if (inherits(cond, "message")) {
[17:26:35.646]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:35.646]                         if (muffled) 
[17:26:35.646]                           invokeRestart("muffleMessage")
[17:26:35.646]                       }
[17:26:35.646]                       else if (inherits(cond, "warning")) {
[17:26:35.646]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:35.646]                         if (muffled) 
[17:26:35.646]                           invokeRestart("muffleWarning")
[17:26:35.646]                       }
[17:26:35.646]                       else if (inherits(cond, "condition")) {
[17:26:35.646]                         if (!is.null(pattern)) {
[17:26:35.646]                           computeRestarts <- base::computeRestarts
[17:26:35.646]                           grepl <- base::grepl
[17:26:35.646]                           restarts <- computeRestarts(cond)
[17:26:35.646]                           for (restart in restarts) {
[17:26:35.646]                             name <- restart$name
[17:26:35.646]                             if (is.null(name)) 
[17:26:35.646]                               next
[17:26:35.646]                             if (!grepl(pattern, name)) 
[17:26:35.646]                               next
[17:26:35.646]                             invokeRestart(restart)
[17:26:35.646]                             muffled <- TRUE
[17:26:35.646]                             break
[17:26:35.646]                           }
[17:26:35.646]                         }
[17:26:35.646]                       }
[17:26:35.646]                       invisible(muffled)
[17:26:35.646]                     }
[17:26:35.646]                     muffleCondition(cond, pattern = "^muffle")
[17:26:35.646]                   }
[17:26:35.646]                 }
[17:26:35.646]             }
[17:26:35.646]         }))
[17:26:35.646]     }, error = function(ex) {
[17:26:35.646]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:35.646]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:35.646]                 ...future.rng), started = ...future.startTime, 
[17:26:35.646]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:35.646]             version = "1.8"), class = "FutureResult")
[17:26:35.646]     }, finally = {
[17:26:35.646]         if (!identical(...future.workdir, getwd())) 
[17:26:35.646]             setwd(...future.workdir)
[17:26:35.646]         {
[17:26:35.646]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:35.646]                 ...future.oldOptions$nwarnings <- NULL
[17:26:35.646]             }
[17:26:35.646]             base::options(...future.oldOptions)
[17:26:35.646]             if (.Platform$OS.type == "windows") {
[17:26:35.646]                 old_names <- names(...future.oldEnvVars)
[17:26:35.646]                 envs <- base::Sys.getenv()
[17:26:35.646]                 names <- names(envs)
[17:26:35.646]                 common <- intersect(names, old_names)
[17:26:35.646]                 added <- setdiff(names, old_names)
[17:26:35.646]                 removed <- setdiff(old_names, names)
[17:26:35.646]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:35.646]                   envs[common]]
[17:26:35.646]                 NAMES <- toupper(changed)
[17:26:35.646]                 args <- list()
[17:26:35.646]                 for (kk in seq_along(NAMES)) {
[17:26:35.646]                   name <- changed[[kk]]
[17:26:35.646]                   NAME <- NAMES[[kk]]
[17:26:35.646]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:35.646]                     next
[17:26:35.646]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:35.646]                 }
[17:26:35.646]                 NAMES <- toupper(added)
[17:26:35.646]                 for (kk in seq_along(NAMES)) {
[17:26:35.646]                   name <- added[[kk]]
[17:26:35.646]                   NAME <- NAMES[[kk]]
[17:26:35.646]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:35.646]                     next
[17:26:35.646]                   args[[name]] <- ""
[17:26:35.646]                 }
[17:26:35.646]                 NAMES <- toupper(removed)
[17:26:35.646]                 for (kk in seq_along(NAMES)) {
[17:26:35.646]                   name <- removed[[kk]]
[17:26:35.646]                   NAME <- NAMES[[kk]]
[17:26:35.646]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:35.646]                     next
[17:26:35.646]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:35.646]                 }
[17:26:35.646]                 if (length(args) > 0) 
[17:26:35.646]                   base::do.call(base::Sys.setenv, args = args)
[17:26:35.646]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:35.646]             }
[17:26:35.646]             else {
[17:26:35.646]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:35.646]             }
[17:26:35.646]             {
[17:26:35.646]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:35.646]                   0L) {
[17:26:35.646]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:35.646]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:35.646]                   base::options(opts)
[17:26:35.646]                 }
[17:26:35.646]                 {
[17:26:35.646]                   {
[17:26:35.646]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:35.646]                     NULL
[17:26:35.646]                   }
[17:26:35.646]                   options(future.plan = NULL)
[17:26:35.646]                   if (is.na(NA_character_)) 
[17:26:35.646]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:35.646]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:35.646]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:35.646]                     .init = FALSE)
[17:26:35.646]                 }
[17:26:35.646]             }
[17:26:35.646]         }
[17:26:35.646]     })
[17:26:35.646]     if (TRUE) {
[17:26:35.646]         base::sink(type = "output", split = FALSE)
[17:26:35.646]         if (TRUE) {
[17:26:35.646]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:35.646]         }
[17:26:35.646]         else {
[17:26:35.646]             ...future.result["stdout"] <- base::list(NULL)
[17:26:35.646]         }
[17:26:35.646]         base::close(...future.stdout)
[17:26:35.646]         ...future.stdout <- NULL
[17:26:35.646]     }
[17:26:35.646]     ...future.result$conditions <- ...future.conditions
[17:26:35.646]     ...future.result$finished <- base::Sys.time()
[17:26:35.646]     ...future.result
[17:26:35.646] }
[17:26:35.727] MultisessionFuture started
[17:26:35.727] result() for ClusterFuture ...
[17:26:35.728] receiveMessageFromWorker() for ClusterFuture ...
[17:26:35.728] - Validating connection of MultisessionFuture
[17:26:35.780] - received message: FutureResult
[17:26:35.780] - Received FutureResult
[17:26:35.784] - Erased future from FutureRegistry
[17:26:35.784] result() for ClusterFuture ...
[17:26:35.784] - result already collected: FutureResult
[17:26:35.784] result() for ClusterFuture ... done
[17:26:35.784] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:35.785] result() for ClusterFuture ... done
[17:26:35.785] result() for ClusterFuture ...
[17:26:35.785] - result already collected: FutureResult
[17:26:35.785] result() for ClusterFuture ... done
[17:26:35.785] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[17:26:35.788] plan(): nbrOfWorkers() = 2
** Future evaluation without globals
[17:26:35.789] getGlobalsAndPackages() ...
[17:26:35.789] Searching for globals...
[17:26:35.790] - globals found: [2] '{', '<-'
[17:26:35.791] Searching for globals ... DONE
[17:26:35.791] Resolving globals: FALSE
[17:26:35.791] 
[17:26:35.791] 
[17:26:35.792] getGlobalsAndPackages() ... DONE
[17:26:35.792] run() for 'Future' ...
[17:26:35.792] - state: 'created'
[17:26:35.793] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:35.807] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:35.807] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:35.807]   - Field: 'node'
[17:26:35.807]   - Field: 'label'
[17:26:35.808]   - Field: 'local'
[17:26:35.808]   - Field: 'owner'
[17:26:35.808]   - Field: 'envir'
[17:26:35.808]   - Field: 'workers'
[17:26:35.808]   - Field: 'packages'
[17:26:35.809]   - Field: 'gc'
[17:26:35.809]   - Field: 'conditions'
[17:26:35.809]   - Field: 'persistent'
[17:26:35.809]   - Field: 'expr'
[17:26:35.809]   - Field: 'uuid'
[17:26:35.810]   - Field: 'seed'
[17:26:35.810]   - Field: 'version'
[17:26:35.810]   - Field: 'result'
[17:26:35.810]   - Field: 'asynchronous'
[17:26:35.810]   - Field: 'calls'
[17:26:35.811]   - Field: 'globals'
[17:26:35.811]   - Field: 'stdout'
[17:26:35.811]   - Field: 'earlySignal'
[17:26:35.811]   - Field: 'lazy'
[17:26:35.811]   - Field: 'state'
[17:26:35.812] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:35.812] - Launch lazy future ...
[17:26:35.812] Packages needed by the future expression (n = 0): <none>
[17:26:35.812] Packages needed by future strategies (n = 0): <none>
[17:26:35.813] {
[17:26:35.813]     {
[17:26:35.813]         {
[17:26:35.813]             ...future.startTime <- base::Sys.time()
[17:26:35.813]             {
[17:26:35.813]                 {
[17:26:35.813]                   {
[17:26:35.813]                     {
[17:26:35.813]                       base::local({
[17:26:35.813]                         has_future <- base::requireNamespace("future", 
[17:26:35.813]                           quietly = TRUE)
[17:26:35.813]                         if (has_future) {
[17:26:35.813]                           ns <- base::getNamespace("future")
[17:26:35.813]                           version <- ns[[".package"]][["version"]]
[17:26:35.813]                           if (is.null(version)) 
[17:26:35.813]                             version <- utils::packageVersion("future")
[17:26:35.813]                         }
[17:26:35.813]                         else {
[17:26:35.813]                           version <- NULL
[17:26:35.813]                         }
[17:26:35.813]                         if (!has_future || version < "1.8.0") {
[17:26:35.813]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:35.813]                             "", base::R.version$version.string), 
[17:26:35.813]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:35.813]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:35.813]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:35.813]                               "release", "version")], collapse = " "), 
[17:26:35.813]                             hostname = base::Sys.info()[["nodename"]])
[17:26:35.813]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:35.813]                             info)
[17:26:35.813]                           info <- base::paste(info, collapse = "; ")
[17:26:35.813]                           if (!has_future) {
[17:26:35.813]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:35.813]                               info)
[17:26:35.813]                           }
[17:26:35.813]                           else {
[17:26:35.813]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:35.813]                               info, version)
[17:26:35.813]                           }
[17:26:35.813]                           base::stop(msg)
[17:26:35.813]                         }
[17:26:35.813]                       })
[17:26:35.813]                     }
[17:26:35.813]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:35.813]                     base::options(mc.cores = 1L)
[17:26:35.813]                   }
[17:26:35.813]                   ...future.strategy.old <- future::plan("list")
[17:26:35.813]                   options(future.plan = NULL)
[17:26:35.813]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:35.813]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:35.813]                 }
[17:26:35.813]                 ...future.workdir <- getwd()
[17:26:35.813]             }
[17:26:35.813]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:35.813]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:35.813]         }
[17:26:35.813]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:35.813]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:35.813]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:35.813]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:35.813]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:35.813]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:35.813]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:35.813]             base::names(...future.oldOptions))
[17:26:35.813]     }
[17:26:35.813]     if (FALSE) {
[17:26:35.813]     }
[17:26:35.813]     else {
[17:26:35.813]         if (TRUE) {
[17:26:35.813]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:35.813]                 open = "w")
[17:26:35.813]         }
[17:26:35.813]         else {
[17:26:35.813]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:35.813]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:35.813]         }
[17:26:35.813]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:35.813]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:35.813]             base::sink(type = "output", split = FALSE)
[17:26:35.813]             base::close(...future.stdout)
[17:26:35.813]         }, add = TRUE)
[17:26:35.813]     }
[17:26:35.813]     ...future.frame <- base::sys.nframe()
[17:26:35.813]     ...future.conditions <- base::list()
[17:26:35.813]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:35.813]     if (FALSE) {
[17:26:35.813]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:35.813]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:35.813]     }
[17:26:35.813]     ...future.result <- base::tryCatch({
[17:26:35.813]         base::withCallingHandlers({
[17:26:35.813]             ...future.value <- base::withVisible(base::local({
[17:26:35.813]                 ...future.makeSendCondition <- base::local({
[17:26:35.813]                   sendCondition <- NULL
[17:26:35.813]                   function(frame = 1L) {
[17:26:35.813]                     if (is.function(sendCondition)) 
[17:26:35.813]                       return(sendCondition)
[17:26:35.813]                     ns <- getNamespace("parallel")
[17:26:35.813]                     if (exists("sendData", mode = "function", 
[17:26:35.813]                       envir = ns)) {
[17:26:35.813]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:35.813]                         envir = ns)
[17:26:35.813]                       envir <- sys.frame(frame)
[17:26:35.813]                       master <- NULL
[17:26:35.813]                       while (!identical(envir, .GlobalEnv) && 
[17:26:35.813]                         !identical(envir, emptyenv())) {
[17:26:35.813]                         if (exists("master", mode = "list", envir = envir, 
[17:26:35.813]                           inherits = FALSE)) {
[17:26:35.813]                           master <- get("master", mode = "list", 
[17:26:35.813]                             envir = envir, inherits = FALSE)
[17:26:35.813]                           if (inherits(master, c("SOCKnode", 
[17:26:35.813]                             "SOCK0node"))) {
[17:26:35.813]                             sendCondition <<- function(cond) {
[17:26:35.813]                               data <- list(type = "VALUE", value = cond, 
[17:26:35.813]                                 success = TRUE)
[17:26:35.813]                               parallel_sendData(master, data)
[17:26:35.813]                             }
[17:26:35.813]                             return(sendCondition)
[17:26:35.813]                           }
[17:26:35.813]                         }
[17:26:35.813]                         frame <- frame + 1L
[17:26:35.813]                         envir <- sys.frame(frame)
[17:26:35.813]                       }
[17:26:35.813]                     }
[17:26:35.813]                     sendCondition <<- function(cond) NULL
[17:26:35.813]                   }
[17:26:35.813]                 })
[17:26:35.813]                 withCallingHandlers({
[17:26:35.813]                   {
[17:26:35.813]                     x <- 1
[17:26:35.813]                   }
[17:26:35.813]                 }, immediateCondition = function(cond) {
[17:26:35.813]                   sendCondition <- ...future.makeSendCondition()
[17:26:35.813]                   sendCondition(cond)
[17:26:35.813]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:35.813]                   {
[17:26:35.813]                     inherits <- base::inherits
[17:26:35.813]                     invokeRestart <- base::invokeRestart
[17:26:35.813]                     is.null <- base::is.null
[17:26:35.813]                     muffled <- FALSE
[17:26:35.813]                     if (inherits(cond, "message")) {
[17:26:35.813]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:35.813]                       if (muffled) 
[17:26:35.813]                         invokeRestart("muffleMessage")
[17:26:35.813]                     }
[17:26:35.813]                     else if (inherits(cond, "warning")) {
[17:26:35.813]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:35.813]                       if (muffled) 
[17:26:35.813]                         invokeRestart("muffleWarning")
[17:26:35.813]                     }
[17:26:35.813]                     else if (inherits(cond, "condition")) {
[17:26:35.813]                       if (!is.null(pattern)) {
[17:26:35.813]                         computeRestarts <- base::computeRestarts
[17:26:35.813]                         grepl <- base::grepl
[17:26:35.813]                         restarts <- computeRestarts(cond)
[17:26:35.813]                         for (restart in restarts) {
[17:26:35.813]                           name <- restart$name
[17:26:35.813]                           if (is.null(name)) 
[17:26:35.813]                             next
[17:26:35.813]                           if (!grepl(pattern, name)) 
[17:26:35.813]                             next
[17:26:35.813]                           invokeRestart(restart)
[17:26:35.813]                           muffled <- TRUE
[17:26:35.813]                           break
[17:26:35.813]                         }
[17:26:35.813]                       }
[17:26:35.813]                     }
[17:26:35.813]                     invisible(muffled)
[17:26:35.813]                   }
[17:26:35.813]                   muffleCondition(cond)
[17:26:35.813]                 })
[17:26:35.813]             }))
[17:26:35.813]             future::FutureResult(value = ...future.value$value, 
[17:26:35.813]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:35.813]                   ...future.rng), globalenv = if (FALSE) 
[17:26:35.813]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:35.813]                     ...future.globalenv.names))
[17:26:35.813]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:35.813]         }, condition = base::local({
[17:26:35.813]             c <- base::c
[17:26:35.813]             inherits <- base::inherits
[17:26:35.813]             invokeRestart <- base::invokeRestart
[17:26:35.813]             length <- base::length
[17:26:35.813]             list <- base::list
[17:26:35.813]             seq.int <- base::seq.int
[17:26:35.813]             signalCondition <- base::signalCondition
[17:26:35.813]             sys.calls <- base::sys.calls
[17:26:35.813]             `[[` <- base::`[[`
[17:26:35.813]             `+` <- base::`+`
[17:26:35.813]             `<<-` <- base::`<<-`
[17:26:35.813]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:35.813]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:35.813]                   3L)]
[17:26:35.813]             }
[17:26:35.813]             function(cond) {
[17:26:35.813]                 is_error <- inherits(cond, "error")
[17:26:35.813]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:35.813]                   NULL)
[17:26:35.813]                 if (is_error) {
[17:26:35.813]                   sessionInformation <- function() {
[17:26:35.813]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:35.813]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:35.813]                       search = base::search(), system = base::Sys.info())
[17:26:35.813]                   }
[17:26:35.813]                   ...future.conditions[[length(...future.conditions) + 
[17:26:35.813]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:35.813]                     cond$call), session = sessionInformation(), 
[17:26:35.813]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:35.813]                   signalCondition(cond)
[17:26:35.813]                 }
[17:26:35.813]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:35.813]                 "immediateCondition"))) {
[17:26:35.813]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:35.813]                   ...future.conditions[[length(...future.conditions) + 
[17:26:35.813]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:35.813]                   if (TRUE && !signal) {
[17:26:35.813]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:35.813]                     {
[17:26:35.813]                       inherits <- base::inherits
[17:26:35.813]                       invokeRestart <- base::invokeRestart
[17:26:35.813]                       is.null <- base::is.null
[17:26:35.813]                       muffled <- FALSE
[17:26:35.813]                       if (inherits(cond, "message")) {
[17:26:35.813]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:35.813]                         if (muffled) 
[17:26:35.813]                           invokeRestart("muffleMessage")
[17:26:35.813]                       }
[17:26:35.813]                       else if (inherits(cond, "warning")) {
[17:26:35.813]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:35.813]                         if (muffled) 
[17:26:35.813]                           invokeRestart("muffleWarning")
[17:26:35.813]                       }
[17:26:35.813]                       else if (inherits(cond, "condition")) {
[17:26:35.813]                         if (!is.null(pattern)) {
[17:26:35.813]                           computeRestarts <- base::computeRestarts
[17:26:35.813]                           grepl <- base::grepl
[17:26:35.813]                           restarts <- computeRestarts(cond)
[17:26:35.813]                           for (restart in restarts) {
[17:26:35.813]                             name <- restart$name
[17:26:35.813]                             if (is.null(name)) 
[17:26:35.813]                               next
[17:26:35.813]                             if (!grepl(pattern, name)) 
[17:26:35.813]                               next
[17:26:35.813]                             invokeRestart(restart)
[17:26:35.813]                             muffled <- TRUE
[17:26:35.813]                             break
[17:26:35.813]                           }
[17:26:35.813]                         }
[17:26:35.813]                       }
[17:26:35.813]                       invisible(muffled)
[17:26:35.813]                     }
[17:26:35.813]                     muffleCondition(cond, pattern = "^muffle")
[17:26:35.813]                   }
[17:26:35.813]                 }
[17:26:35.813]                 else {
[17:26:35.813]                   if (TRUE) {
[17:26:35.813]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:35.813]                     {
[17:26:35.813]                       inherits <- base::inherits
[17:26:35.813]                       invokeRestart <- base::invokeRestart
[17:26:35.813]                       is.null <- base::is.null
[17:26:35.813]                       muffled <- FALSE
[17:26:35.813]                       if (inherits(cond, "message")) {
[17:26:35.813]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:35.813]                         if (muffled) 
[17:26:35.813]                           invokeRestart("muffleMessage")
[17:26:35.813]                       }
[17:26:35.813]                       else if (inherits(cond, "warning")) {
[17:26:35.813]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:35.813]                         if (muffled) 
[17:26:35.813]                           invokeRestart("muffleWarning")
[17:26:35.813]                       }
[17:26:35.813]                       else if (inherits(cond, "condition")) {
[17:26:35.813]                         if (!is.null(pattern)) {
[17:26:35.813]                           computeRestarts <- base::computeRestarts
[17:26:35.813]                           grepl <- base::grepl
[17:26:35.813]                           restarts <- computeRestarts(cond)
[17:26:35.813]                           for (restart in restarts) {
[17:26:35.813]                             name <- restart$name
[17:26:35.813]                             if (is.null(name)) 
[17:26:35.813]                               next
[17:26:35.813]                             if (!grepl(pattern, name)) 
[17:26:35.813]                               next
[17:26:35.813]                             invokeRestart(restart)
[17:26:35.813]                             muffled <- TRUE
[17:26:35.813]                             break
[17:26:35.813]                           }
[17:26:35.813]                         }
[17:26:35.813]                       }
[17:26:35.813]                       invisible(muffled)
[17:26:35.813]                     }
[17:26:35.813]                     muffleCondition(cond, pattern = "^muffle")
[17:26:35.813]                   }
[17:26:35.813]                 }
[17:26:35.813]             }
[17:26:35.813]         }))
[17:26:35.813]     }, error = function(ex) {
[17:26:35.813]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:35.813]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:35.813]                 ...future.rng), started = ...future.startTime, 
[17:26:35.813]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:35.813]             version = "1.8"), class = "FutureResult")
[17:26:35.813]     }, finally = {
[17:26:35.813]         if (!identical(...future.workdir, getwd())) 
[17:26:35.813]             setwd(...future.workdir)
[17:26:35.813]         {
[17:26:35.813]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:35.813]                 ...future.oldOptions$nwarnings <- NULL
[17:26:35.813]             }
[17:26:35.813]             base::options(...future.oldOptions)
[17:26:35.813]             if (.Platform$OS.type == "windows") {
[17:26:35.813]                 old_names <- names(...future.oldEnvVars)
[17:26:35.813]                 envs <- base::Sys.getenv()
[17:26:35.813]                 names <- names(envs)
[17:26:35.813]                 common <- intersect(names, old_names)
[17:26:35.813]                 added <- setdiff(names, old_names)
[17:26:35.813]                 removed <- setdiff(old_names, names)
[17:26:35.813]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:35.813]                   envs[common]]
[17:26:35.813]                 NAMES <- toupper(changed)
[17:26:35.813]                 args <- list()
[17:26:35.813]                 for (kk in seq_along(NAMES)) {
[17:26:35.813]                   name <- changed[[kk]]
[17:26:35.813]                   NAME <- NAMES[[kk]]
[17:26:35.813]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:35.813]                     next
[17:26:35.813]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:35.813]                 }
[17:26:35.813]                 NAMES <- toupper(added)
[17:26:35.813]                 for (kk in seq_along(NAMES)) {
[17:26:35.813]                   name <- added[[kk]]
[17:26:35.813]                   NAME <- NAMES[[kk]]
[17:26:35.813]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:35.813]                     next
[17:26:35.813]                   args[[name]] <- ""
[17:26:35.813]                 }
[17:26:35.813]                 NAMES <- toupper(removed)
[17:26:35.813]                 for (kk in seq_along(NAMES)) {
[17:26:35.813]                   name <- removed[[kk]]
[17:26:35.813]                   NAME <- NAMES[[kk]]
[17:26:35.813]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:35.813]                     next
[17:26:35.813]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:35.813]                 }
[17:26:35.813]                 if (length(args) > 0) 
[17:26:35.813]                   base::do.call(base::Sys.setenv, args = args)
[17:26:35.813]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:35.813]             }
[17:26:35.813]             else {
[17:26:35.813]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:35.813]             }
[17:26:35.813]             {
[17:26:35.813]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:35.813]                   0L) {
[17:26:35.813]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:35.813]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:35.813]                   base::options(opts)
[17:26:35.813]                 }
[17:26:35.813]                 {
[17:26:35.813]                   {
[17:26:35.813]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:35.813]                     NULL
[17:26:35.813]                   }
[17:26:35.813]                   options(future.plan = NULL)
[17:26:35.813]                   if (is.na(NA_character_)) 
[17:26:35.813]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:35.813]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:35.813]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:35.813]                     .init = FALSE)
[17:26:35.813]                 }
[17:26:35.813]             }
[17:26:35.813]         }
[17:26:35.813]     })
[17:26:35.813]     if (TRUE) {
[17:26:35.813]         base::sink(type = "output", split = FALSE)
[17:26:35.813]         if (TRUE) {
[17:26:35.813]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:35.813]         }
[17:26:35.813]         else {
[17:26:35.813]             ...future.result["stdout"] <- base::list(NULL)
[17:26:35.813]         }
[17:26:35.813]         base::close(...future.stdout)
[17:26:35.813]         ...future.stdout <- NULL
[17:26:35.813]     }
[17:26:35.813]     ...future.result$conditions <- ...future.conditions
[17:26:35.813]     ...future.result$finished <- base::Sys.time()
[17:26:35.813]     ...future.result
[17:26:35.813] }
[17:26:35.819] MultisessionFuture started
[17:26:35.819] - Launch lazy future ... done
[17:26:35.819] run() for 'MultisessionFuture' ... done
[17:26:35.820] result() for ClusterFuture ...
[17:26:35.820] receiveMessageFromWorker() for ClusterFuture ...
[17:26:35.820] - Validating connection of MultisessionFuture
[17:26:35.834] - received message: FutureResult
[17:26:35.834] - Received FutureResult
[17:26:35.834] - Erased future from FutureRegistry
[17:26:35.835] result() for ClusterFuture ...
[17:26:35.835] - result already collected: FutureResult
[17:26:35.835] result() for ClusterFuture ... done
[17:26:35.835] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:35.835] result() for ClusterFuture ... done
[17:26:35.836] result() for ClusterFuture ...
[17:26:35.836] - result already collected: FutureResult
[17:26:35.836] result() for ClusterFuture ... done
** Future evaluation with globals
[17:26:35.836] getGlobalsAndPackages() ...
[17:26:35.837] Searching for globals...
[17:26:35.838] - globals found: [3] '{', '<-', 'a'
[17:26:35.838] Searching for globals ... DONE
[17:26:35.839] Resolving globals: FALSE
[17:26:35.839] The total size of the 1 globals is 56 bytes (56 bytes)
[17:26:35.840] The total size of the 1 globals exported for future expression ('{; x <- a; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'a' (56 bytes of class 'numeric')
[17:26:35.840] - globals: [1] 'a'
[17:26:35.840] 
[17:26:35.840] getGlobalsAndPackages() ... DONE
[17:26:35.841] run() for 'Future' ...
[17:26:35.841] - state: 'created'
[17:26:35.841] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:35.855] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:35.855] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:35.856]   - Field: 'node'
[17:26:35.856]   - Field: 'label'
[17:26:35.856]   - Field: 'local'
[17:26:35.856]   - Field: 'owner'
[17:26:35.856]   - Field: 'envir'
[17:26:35.857]   - Field: 'workers'
[17:26:35.857]   - Field: 'packages'
[17:26:35.857]   - Field: 'gc'
[17:26:35.857]   - Field: 'conditions'
[17:26:35.857]   - Field: 'persistent'
[17:26:35.858]   - Field: 'expr'
[17:26:35.858]   - Field: 'uuid'
[17:26:35.858]   - Field: 'seed'
[17:26:35.858]   - Field: 'version'
[17:26:35.858]   - Field: 'result'
[17:26:35.859]   - Field: 'asynchronous'
[17:26:35.859]   - Field: 'calls'
[17:26:35.859]   - Field: 'globals'
[17:26:35.859]   - Field: 'stdout'
[17:26:35.859]   - Field: 'earlySignal'
[17:26:35.860]   - Field: 'lazy'
[17:26:35.860]   - Field: 'state'
[17:26:35.860] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:35.860] - Launch lazy future ...
[17:26:35.861] Packages needed by the future expression (n = 0): <none>
[17:26:35.861] Packages needed by future strategies (n = 0): <none>
[17:26:35.861] {
[17:26:35.861]     {
[17:26:35.861]         {
[17:26:35.861]             ...future.startTime <- base::Sys.time()
[17:26:35.861]             {
[17:26:35.861]                 {
[17:26:35.861]                   {
[17:26:35.861]                     {
[17:26:35.861]                       base::local({
[17:26:35.861]                         has_future <- base::requireNamespace("future", 
[17:26:35.861]                           quietly = TRUE)
[17:26:35.861]                         if (has_future) {
[17:26:35.861]                           ns <- base::getNamespace("future")
[17:26:35.861]                           version <- ns[[".package"]][["version"]]
[17:26:35.861]                           if (is.null(version)) 
[17:26:35.861]                             version <- utils::packageVersion("future")
[17:26:35.861]                         }
[17:26:35.861]                         else {
[17:26:35.861]                           version <- NULL
[17:26:35.861]                         }
[17:26:35.861]                         if (!has_future || version < "1.8.0") {
[17:26:35.861]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:35.861]                             "", base::R.version$version.string), 
[17:26:35.861]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:35.861]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:35.861]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:35.861]                               "release", "version")], collapse = " "), 
[17:26:35.861]                             hostname = base::Sys.info()[["nodename"]])
[17:26:35.861]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:35.861]                             info)
[17:26:35.861]                           info <- base::paste(info, collapse = "; ")
[17:26:35.861]                           if (!has_future) {
[17:26:35.861]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:35.861]                               info)
[17:26:35.861]                           }
[17:26:35.861]                           else {
[17:26:35.861]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:35.861]                               info, version)
[17:26:35.861]                           }
[17:26:35.861]                           base::stop(msg)
[17:26:35.861]                         }
[17:26:35.861]                       })
[17:26:35.861]                     }
[17:26:35.861]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:35.861]                     base::options(mc.cores = 1L)
[17:26:35.861]                   }
[17:26:35.861]                   ...future.strategy.old <- future::plan("list")
[17:26:35.861]                   options(future.plan = NULL)
[17:26:35.861]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:35.861]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:35.861]                 }
[17:26:35.861]                 ...future.workdir <- getwd()
[17:26:35.861]             }
[17:26:35.861]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:35.861]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:35.861]         }
[17:26:35.861]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:35.861]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:35.861]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:35.861]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:35.861]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:35.861]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:35.861]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:35.861]             base::names(...future.oldOptions))
[17:26:35.861]     }
[17:26:35.861]     if (FALSE) {
[17:26:35.861]     }
[17:26:35.861]     else {
[17:26:35.861]         if (TRUE) {
[17:26:35.861]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:35.861]                 open = "w")
[17:26:35.861]         }
[17:26:35.861]         else {
[17:26:35.861]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:35.861]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:35.861]         }
[17:26:35.861]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:35.861]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:35.861]             base::sink(type = "output", split = FALSE)
[17:26:35.861]             base::close(...future.stdout)
[17:26:35.861]         }, add = TRUE)
[17:26:35.861]     }
[17:26:35.861]     ...future.frame <- base::sys.nframe()
[17:26:35.861]     ...future.conditions <- base::list()
[17:26:35.861]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:35.861]     if (FALSE) {
[17:26:35.861]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:35.861]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:35.861]     }
[17:26:35.861]     ...future.result <- base::tryCatch({
[17:26:35.861]         base::withCallingHandlers({
[17:26:35.861]             ...future.value <- base::withVisible(base::local({
[17:26:35.861]                 ...future.makeSendCondition <- base::local({
[17:26:35.861]                   sendCondition <- NULL
[17:26:35.861]                   function(frame = 1L) {
[17:26:35.861]                     if (is.function(sendCondition)) 
[17:26:35.861]                       return(sendCondition)
[17:26:35.861]                     ns <- getNamespace("parallel")
[17:26:35.861]                     if (exists("sendData", mode = "function", 
[17:26:35.861]                       envir = ns)) {
[17:26:35.861]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:35.861]                         envir = ns)
[17:26:35.861]                       envir <- sys.frame(frame)
[17:26:35.861]                       master <- NULL
[17:26:35.861]                       while (!identical(envir, .GlobalEnv) && 
[17:26:35.861]                         !identical(envir, emptyenv())) {
[17:26:35.861]                         if (exists("master", mode = "list", envir = envir, 
[17:26:35.861]                           inherits = FALSE)) {
[17:26:35.861]                           master <- get("master", mode = "list", 
[17:26:35.861]                             envir = envir, inherits = FALSE)
[17:26:35.861]                           if (inherits(master, c("SOCKnode", 
[17:26:35.861]                             "SOCK0node"))) {
[17:26:35.861]                             sendCondition <<- function(cond) {
[17:26:35.861]                               data <- list(type = "VALUE", value = cond, 
[17:26:35.861]                                 success = TRUE)
[17:26:35.861]                               parallel_sendData(master, data)
[17:26:35.861]                             }
[17:26:35.861]                             return(sendCondition)
[17:26:35.861]                           }
[17:26:35.861]                         }
[17:26:35.861]                         frame <- frame + 1L
[17:26:35.861]                         envir <- sys.frame(frame)
[17:26:35.861]                       }
[17:26:35.861]                     }
[17:26:35.861]                     sendCondition <<- function(cond) NULL
[17:26:35.861]                   }
[17:26:35.861]                 })
[17:26:35.861]                 withCallingHandlers({
[17:26:35.861]                   {
[17:26:35.861]                     x <- a
[17:26:35.861]                   }
[17:26:35.861]                 }, immediateCondition = function(cond) {
[17:26:35.861]                   sendCondition <- ...future.makeSendCondition()
[17:26:35.861]                   sendCondition(cond)
[17:26:35.861]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:35.861]                   {
[17:26:35.861]                     inherits <- base::inherits
[17:26:35.861]                     invokeRestart <- base::invokeRestart
[17:26:35.861]                     is.null <- base::is.null
[17:26:35.861]                     muffled <- FALSE
[17:26:35.861]                     if (inherits(cond, "message")) {
[17:26:35.861]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:35.861]                       if (muffled) 
[17:26:35.861]                         invokeRestart("muffleMessage")
[17:26:35.861]                     }
[17:26:35.861]                     else if (inherits(cond, "warning")) {
[17:26:35.861]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:35.861]                       if (muffled) 
[17:26:35.861]                         invokeRestart("muffleWarning")
[17:26:35.861]                     }
[17:26:35.861]                     else if (inherits(cond, "condition")) {
[17:26:35.861]                       if (!is.null(pattern)) {
[17:26:35.861]                         computeRestarts <- base::computeRestarts
[17:26:35.861]                         grepl <- base::grepl
[17:26:35.861]                         restarts <- computeRestarts(cond)
[17:26:35.861]                         for (restart in restarts) {
[17:26:35.861]                           name <- restart$name
[17:26:35.861]                           if (is.null(name)) 
[17:26:35.861]                             next
[17:26:35.861]                           if (!grepl(pattern, name)) 
[17:26:35.861]                             next
[17:26:35.861]                           invokeRestart(restart)
[17:26:35.861]                           muffled <- TRUE
[17:26:35.861]                           break
[17:26:35.861]                         }
[17:26:35.861]                       }
[17:26:35.861]                     }
[17:26:35.861]                     invisible(muffled)
[17:26:35.861]                   }
[17:26:35.861]                   muffleCondition(cond)
[17:26:35.861]                 })
[17:26:35.861]             }))
[17:26:35.861]             future::FutureResult(value = ...future.value$value, 
[17:26:35.861]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:35.861]                   ...future.rng), globalenv = if (FALSE) 
[17:26:35.861]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:35.861]                     ...future.globalenv.names))
[17:26:35.861]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:35.861]         }, condition = base::local({
[17:26:35.861]             c <- base::c
[17:26:35.861]             inherits <- base::inherits
[17:26:35.861]             invokeRestart <- base::invokeRestart
[17:26:35.861]             length <- base::length
[17:26:35.861]             list <- base::list
[17:26:35.861]             seq.int <- base::seq.int
[17:26:35.861]             signalCondition <- base::signalCondition
[17:26:35.861]             sys.calls <- base::sys.calls
[17:26:35.861]             `[[` <- base::`[[`
[17:26:35.861]             `+` <- base::`+`
[17:26:35.861]             `<<-` <- base::`<<-`
[17:26:35.861]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:35.861]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:35.861]                   3L)]
[17:26:35.861]             }
[17:26:35.861]             function(cond) {
[17:26:35.861]                 is_error <- inherits(cond, "error")
[17:26:35.861]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:35.861]                   NULL)
[17:26:35.861]                 if (is_error) {
[17:26:35.861]                   sessionInformation <- function() {
[17:26:35.861]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:35.861]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:35.861]                       search = base::search(), system = base::Sys.info())
[17:26:35.861]                   }
[17:26:35.861]                   ...future.conditions[[length(...future.conditions) + 
[17:26:35.861]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:35.861]                     cond$call), session = sessionInformation(), 
[17:26:35.861]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:35.861]                   signalCondition(cond)
[17:26:35.861]                 }
[17:26:35.861]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:35.861]                 "immediateCondition"))) {
[17:26:35.861]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:35.861]                   ...future.conditions[[length(...future.conditions) + 
[17:26:35.861]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:35.861]                   if (TRUE && !signal) {
[17:26:35.861]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:35.861]                     {
[17:26:35.861]                       inherits <- base::inherits
[17:26:35.861]                       invokeRestart <- base::invokeRestart
[17:26:35.861]                       is.null <- base::is.null
[17:26:35.861]                       muffled <- FALSE
[17:26:35.861]                       if (inherits(cond, "message")) {
[17:26:35.861]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:35.861]                         if (muffled) 
[17:26:35.861]                           invokeRestart("muffleMessage")
[17:26:35.861]                       }
[17:26:35.861]                       else if (inherits(cond, "warning")) {
[17:26:35.861]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:35.861]                         if (muffled) 
[17:26:35.861]                           invokeRestart("muffleWarning")
[17:26:35.861]                       }
[17:26:35.861]                       else if (inherits(cond, "condition")) {
[17:26:35.861]                         if (!is.null(pattern)) {
[17:26:35.861]                           computeRestarts <- base::computeRestarts
[17:26:35.861]                           grepl <- base::grepl
[17:26:35.861]                           restarts <- computeRestarts(cond)
[17:26:35.861]                           for (restart in restarts) {
[17:26:35.861]                             name <- restart$name
[17:26:35.861]                             if (is.null(name)) 
[17:26:35.861]                               next
[17:26:35.861]                             if (!grepl(pattern, name)) 
[17:26:35.861]                               next
[17:26:35.861]                             invokeRestart(restart)
[17:26:35.861]                             muffled <- TRUE
[17:26:35.861]                             break
[17:26:35.861]                           }
[17:26:35.861]                         }
[17:26:35.861]                       }
[17:26:35.861]                       invisible(muffled)
[17:26:35.861]                     }
[17:26:35.861]                     muffleCondition(cond, pattern = "^muffle")
[17:26:35.861]                   }
[17:26:35.861]                 }
[17:26:35.861]                 else {
[17:26:35.861]                   if (TRUE) {
[17:26:35.861]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:35.861]                     {
[17:26:35.861]                       inherits <- base::inherits
[17:26:35.861]                       invokeRestart <- base::invokeRestart
[17:26:35.861]                       is.null <- base::is.null
[17:26:35.861]                       muffled <- FALSE
[17:26:35.861]                       if (inherits(cond, "message")) {
[17:26:35.861]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:35.861]                         if (muffled) 
[17:26:35.861]                           invokeRestart("muffleMessage")
[17:26:35.861]                       }
[17:26:35.861]                       else if (inherits(cond, "warning")) {
[17:26:35.861]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:35.861]                         if (muffled) 
[17:26:35.861]                           invokeRestart("muffleWarning")
[17:26:35.861]                       }
[17:26:35.861]                       else if (inherits(cond, "condition")) {
[17:26:35.861]                         if (!is.null(pattern)) {
[17:26:35.861]                           computeRestarts <- base::computeRestarts
[17:26:35.861]                           grepl <- base::grepl
[17:26:35.861]                           restarts <- computeRestarts(cond)
[17:26:35.861]                           for (restart in restarts) {
[17:26:35.861]                             name <- restart$name
[17:26:35.861]                             if (is.null(name)) 
[17:26:35.861]                               next
[17:26:35.861]                             if (!grepl(pattern, name)) 
[17:26:35.861]                               next
[17:26:35.861]                             invokeRestart(restart)
[17:26:35.861]                             muffled <- TRUE
[17:26:35.861]                             break
[17:26:35.861]                           }
[17:26:35.861]                         }
[17:26:35.861]                       }
[17:26:35.861]                       invisible(muffled)
[17:26:35.861]                     }
[17:26:35.861]                     muffleCondition(cond, pattern = "^muffle")
[17:26:35.861]                   }
[17:26:35.861]                 }
[17:26:35.861]             }
[17:26:35.861]         }))
[17:26:35.861]     }, error = function(ex) {
[17:26:35.861]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:35.861]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:35.861]                 ...future.rng), started = ...future.startTime, 
[17:26:35.861]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:35.861]             version = "1.8"), class = "FutureResult")
[17:26:35.861]     }, finally = {
[17:26:35.861]         if (!identical(...future.workdir, getwd())) 
[17:26:35.861]             setwd(...future.workdir)
[17:26:35.861]         {
[17:26:35.861]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:35.861]                 ...future.oldOptions$nwarnings <- NULL
[17:26:35.861]             }
[17:26:35.861]             base::options(...future.oldOptions)
[17:26:35.861]             if (.Platform$OS.type == "windows") {
[17:26:35.861]                 old_names <- names(...future.oldEnvVars)
[17:26:35.861]                 envs <- base::Sys.getenv()
[17:26:35.861]                 names <- names(envs)
[17:26:35.861]                 common <- intersect(names, old_names)
[17:26:35.861]                 added <- setdiff(names, old_names)
[17:26:35.861]                 removed <- setdiff(old_names, names)
[17:26:35.861]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:35.861]                   envs[common]]
[17:26:35.861]                 NAMES <- toupper(changed)
[17:26:35.861]                 args <- list()
[17:26:35.861]                 for (kk in seq_along(NAMES)) {
[17:26:35.861]                   name <- changed[[kk]]
[17:26:35.861]                   NAME <- NAMES[[kk]]
[17:26:35.861]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:35.861]                     next
[17:26:35.861]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:35.861]                 }
[17:26:35.861]                 NAMES <- toupper(added)
[17:26:35.861]                 for (kk in seq_along(NAMES)) {
[17:26:35.861]                   name <- added[[kk]]
[17:26:35.861]                   NAME <- NAMES[[kk]]
[17:26:35.861]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:35.861]                     next
[17:26:35.861]                   args[[name]] <- ""
[17:26:35.861]                 }
[17:26:35.861]                 NAMES <- toupper(removed)
[17:26:35.861]                 for (kk in seq_along(NAMES)) {
[17:26:35.861]                   name <- removed[[kk]]
[17:26:35.861]                   NAME <- NAMES[[kk]]
[17:26:35.861]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:35.861]                     next
[17:26:35.861]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:35.861]                 }
[17:26:35.861]                 if (length(args) > 0) 
[17:26:35.861]                   base::do.call(base::Sys.setenv, args = args)
[17:26:35.861]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:35.861]             }
[17:26:35.861]             else {
[17:26:35.861]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:35.861]             }
[17:26:35.861]             {
[17:26:35.861]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:35.861]                   0L) {
[17:26:35.861]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:35.861]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:35.861]                   base::options(opts)
[17:26:35.861]                 }
[17:26:35.861]                 {
[17:26:35.861]                   {
[17:26:35.861]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:35.861]                     NULL
[17:26:35.861]                   }
[17:26:35.861]                   options(future.plan = NULL)
[17:26:35.861]                   if (is.na(NA_character_)) 
[17:26:35.861]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:35.861]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:35.861]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:35.861]                     .init = FALSE)
[17:26:35.861]                 }
[17:26:35.861]             }
[17:26:35.861]         }
[17:26:35.861]     })
[17:26:35.861]     if (TRUE) {
[17:26:35.861]         base::sink(type = "output", split = FALSE)
[17:26:35.861]         if (TRUE) {
[17:26:35.861]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:35.861]         }
[17:26:35.861]         else {
[17:26:35.861]             ...future.result["stdout"] <- base::list(NULL)
[17:26:35.861]         }
[17:26:35.861]         base::close(...future.stdout)
[17:26:35.861]         ...future.stdout <- NULL
[17:26:35.861]     }
[17:26:35.861]     ...future.result$conditions <- ...future.conditions
[17:26:35.861]     ...future.result$finished <- base::Sys.time()
[17:26:35.861]     ...future.result
[17:26:35.861] }
[17:26:35.867] Exporting 1 global objects (56 bytes) to cluster node #1 ...
[17:26:35.867] Exporting 'a' (56 bytes) to cluster node #1 ...
[17:26:35.867] Exporting 'a' (56 bytes) to cluster node #1 ... DONE
[17:26:35.868] Exporting 1 global objects (56 bytes) to cluster node #1 ... DONE
[17:26:35.868] MultisessionFuture started
[17:26:35.869] - Launch lazy future ... done
[17:26:35.869] run() for 'MultisessionFuture' ... done
[17:26:35.869] result() for ClusterFuture ...
[17:26:35.869] receiveMessageFromWorker() for ClusterFuture ...
[17:26:35.870] - Validating connection of MultisessionFuture
[17:26:35.882] - received message: FutureResult
[17:26:35.882] - Received FutureResult
[17:26:35.882] - Erased future from FutureRegistry
[17:26:35.883] result() for ClusterFuture ...
[17:26:35.883] - result already collected: FutureResult
[17:26:35.883] result() for ClusterFuture ... done
[17:26:35.883] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:35.883] result() for ClusterFuture ... done
[17:26:35.884] result() for ClusterFuture ...
[17:26:35.884] - result already collected: FutureResult
[17:26:35.884] result() for ClusterFuture ... done
** Future evaluation with errors
[17:26:35.885] getGlobalsAndPackages() ...
[17:26:35.885] Searching for globals...
[17:26:35.887] - globals found: [3] '{', '<-', 'stop'
[17:26:35.887] Searching for globals ... DONE
[17:26:35.888] Resolving globals: FALSE
[17:26:35.888] 
[17:26:35.888] 
[17:26:35.888] getGlobalsAndPackages() ... DONE
[17:26:35.889] run() for 'Future' ...
[17:26:35.889] - state: 'created'
[17:26:35.889] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:35.904] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:35.904] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:35.904]   - Field: 'node'
[17:26:35.904]   - Field: 'label'
[17:26:35.905]   - Field: 'local'
[17:26:35.905]   - Field: 'owner'
[17:26:35.905]   - Field: 'envir'
[17:26:35.905]   - Field: 'workers'
[17:26:35.905]   - Field: 'packages'
[17:26:35.906]   - Field: 'gc'
[17:26:35.906]   - Field: 'conditions'
[17:26:35.906]   - Field: 'persistent'
[17:26:35.906]   - Field: 'expr'
[17:26:35.906]   - Field: 'uuid'
[17:26:35.907]   - Field: 'seed'
[17:26:35.907]   - Field: 'version'
[17:26:35.907]   - Field: 'result'
[17:26:35.907]   - Field: 'asynchronous'
[17:26:35.907]   - Field: 'calls'
[17:26:35.908]   - Field: 'globals'
[17:26:35.908]   - Field: 'stdout'
[17:26:35.908]   - Field: 'earlySignal'
[17:26:35.908]   - Field: 'lazy'
[17:26:35.908]   - Field: 'state'
[17:26:35.909] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:35.909] - Launch lazy future ...
[17:26:35.909] Packages needed by the future expression (n = 0): <none>
[17:26:35.909] Packages needed by future strategies (n = 0): <none>
[17:26:35.910] {
[17:26:35.910]     {
[17:26:35.910]         {
[17:26:35.910]             ...future.startTime <- base::Sys.time()
[17:26:35.910]             {
[17:26:35.910]                 {
[17:26:35.910]                   {
[17:26:35.910]                     {
[17:26:35.910]                       base::local({
[17:26:35.910]                         has_future <- base::requireNamespace("future", 
[17:26:35.910]                           quietly = TRUE)
[17:26:35.910]                         if (has_future) {
[17:26:35.910]                           ns <- base::getNamespace("future")
[17:26:35.910]                           version <- ns[[".package"]][["version"]]
[17:26:35.910]                           if (is.null(version)) 
[17:26:35.910]                             version <- utils::packageVersion("future")
[17:26:35.910]                         }
[17:26:35.910]                         else {
[17:26:35.910]                           version <- NULL
[17:26:35.910]                         }
[17:26:35.910]                         if (!has_future || version < "1.8.0") {
[17:26:35.910]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:35.910]                             "", base::R.version$version.string), 
[17:26:35.910]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:35.910]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:35.910]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:35.910]                               "release", "version")], collapse = " "), 
[17:26:35.910]                             hostname = base::Sys.info()[["nodename"]])
[17:26:35.910]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:35.910]                             info)
[17:26:35.910]                           info <- base::paste(info, collapse = "; ")
[17:26:35.910]                           if (!has_future) {
[17:26:35.910]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:35.910]                               info)
[17:26:35.910]                           }
[17:26:35.910]                           else {
[17:26:35.910]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:35.910]                               info, version)
[17:26:35.910]                           }
[17:26:35.910]                           base::stop(msg)
[17:26:35.910]                         }
[17:26:35.910]                       })
[17:26:35.910]                     }
[17:26:35.910]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:35.910]                     base::options(mc.cores = 1L)
[17:26:35.910]                   }
[17:26:35.910]                   ...future.strategy.old <- future::plan("list")
[17:26:35.910]                   options(future.plan = NULL)
[17:26:35.910]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:35.910]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:35.910]                 }
[17:26:35.910]                 ...future.workdir <- getwd()
[17:26:35.910]             }
[17:26:35.910]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:35.910]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:35.910]         }
[17:26:35.910]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:35.910]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:35.910]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:35.910]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:35.910]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:35.910]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:35.910]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:35.910]             base::names(...future.oldOptions))
[17:26:35.910]     }
[17:26:35.910]     if (FALSE) {
[17:26:35.910]     }
[17:26:35.910]     else {
[17:26:35.910]         if (TRUE) {
[17:26:35.910]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:35.910]                 open = "w")
[17:26:35.910]         }
[17:26:35.910]         else {
[17:26:35.910]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:35.910]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:35.910]         }
[17:26:35.910]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:35.910]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:35.910]             base::sink(type = "output", split = FALSE)
[17:26:35.910]             base::close(...future.stdout)
[17:26:35.910]         }, add = TRUE)
[17:26:35.910]     }
[17:26:35.910]     ...future.frame <- base::sys.nframe()
[17:26:35.910]     ...future.conditions <- base::list()
[17:26:35.910]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:35.910]     if (FALSE) {
[17:26:35.910]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:35.910]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:35.910]     }
[17:26:35.910]     ...future.result <- base::tryCatch({
[17:26:35.910]         base::withCallingHandlers({
[17:26:35.910]             ...future.value <- base::withVisible(base::local({
[17:26:35.910]                 ...future.makeSendCondition <- base::local({
[17:26:35.910]                   sendCondition <- NULL
[17:26:35.910]                   function(frame = 1L) {
[17:26:35.910]                     if (is.function(sendCondition)) 
[17:26:35.910]                       return(sendCondition)
[17:26:35.910]                     ns <- getNamespace("parallel")
[17:26:35.910]                     if (exists("sendData", mode = "function", 
[17:26:35.910]                       envir = ns)) {
[17:26:35.910]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:35.910]                         envir = ns)
[17:26:35.910]                       envir <- sys.frame(frame)
[17:26:35.910]                       master <- NULL
[17:26:35.910]                       while (!identical(envir, .GlobalEnv) && 
[17:26:35.910]                         !identical(envir, emptyenv())) {
[17:26:35.910]                         if (exists("master", mode = "list", envir = envir, 
[17:26:35.910]                           inherits = FALSE)) {
[17:26:35.910]                           master <- get("master", mode = "list", 
[17:26:35.910]                             envir = envir, inherits = FALSE)
[17:26:35.910]                           if (inherits(master, c("SOCKnode", 
[17:26:35.910]                             "SOCK0node"))) {
[17:26:35.910]                             sendCondition <<- function(cond) {
[17:26:35.910]                               data <- list(type = "VALUE", value = cond, 
[17:26:35.910]                                 success = TRUE)
[17:26:35.910]                               parallel_sendData(master, data)
[17:26:35.910]                             }
[17:26:35.910]                             return(sendCondition)
[17:26:35.910]                           }
[17:26:35.910]                         }
[17:26:35.910]                         frame <- frame + 1L
[17:26:35.910]                         envir <- sys.frame(frame)
[17:26:35.910]                       }
[17:26:35.910]                     }
[17:26:35.910]                     sendCondition <<- function(cond) NULL
[17:26:35.910]                   }
[17:26:35.910]                 })
[17:26:35.910]                 withCallingHandlers({
[17:26:35.910]                   {
[17:26:35.910]                     x <- 3
[17:26:35.910]                     stop("Woops!")
[17:26:35.910]                     x
[17:26:35.910]                   }
[17:26:35.910]                 }, immediateCondition = function(cond) {
[17:26:35.910]                   sendCondition <- ...future.makeSendCondition()
[17:26:35.910]                   sendCondition(cond)
[17:26:35.910]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:35.910]                   {
[17:26:35.910]                     inherits <- base::inherits
[17:26:35.910]                     invokeRestart <- base::invokeRestart
[17:26:35.910]                     is.null <- base::is.null
[17:26:35.910]                     muffled <- FALSE
[17:26:35.910]                     if (inherits(cond, "message")) {
[17:26:35.910]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:35.910]                       if (muffled) 
[17:26:35.910]                         invokeRestart("muffleMessage")
[17:26:35.910]                     }
[17:26:35.910]                     else if (inherits(cond, "warning")) {
[17:26:35.910]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:35.910]                       if (muffled) 
[17:26:35.910]                         invokeRestart("muffleWarning")
[17:26:35.910]                     }
[17:26:35.910]                     else if (inherits(cond, "condition")) {
[17:26:35.910]                       if (!is.null(pattern)) {
[17:26:35.910]                         computeRestarts <- base::computeRestarts
[17:26:35.910]                         grepl <- base::grepl
[17:26:35.910]                         restarts <- computeRestarts(cond)
[17:26:35.910]                         for (restart in restarts) {
[17:26:35.910]                           name <- restart$name
[17:26:35.910]                           if (is.null(name)) 
[17:26:35.910]                             next
[17:26:35.910]                           if (!grepl(pattern, name)) 
[17:26:35.910]                             next
[17:26:35.910]                           invokeRestart(restart)
[17:26:35.910]                           muffled <- TRUE
[17:26:35.910]                           break
[17:26:35.910]                         }
[17:26:35.910]                       }
[17:26:35.910]                     }
[17:26:35.910]                     invisible(muffled)
[17:26:35.910]                   }
[17:26:35.910]                   muffleCondition(cond)
[17:26:35.910]                 })
[17:26:35.910]             }))
[17:26:35.910]             future::FutureResult(value = ...future.value$value, 
[17:26:35.910]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:35.910]                   ...future.rng), globalenv = if (FALSE) 
[17:26:35.910]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:35.910]                     ...future.globalenv.names))
[17:26:35.910]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:35.910]         }, condition = base::local({
[17:26:35.910]             c <- base::c
[17:26:35.910]             inherits <- base::inherits
[17:26:35.910]             invokeRestart <- base::invokeRestart
[17:26:35.910]             length <- base::length
[17:26:35.910]             list <- base::list
[17:26:35.910]             seq.int <- base::seq.int
[17:26:35.910]             signalCondition <- base::signalCondition
[17:26:35.910]             sys.calls <- base::sys.calls
[17:26:35.910]             `[[` <- base::`[[`
[17:26:35.910]             `+` <- base::`+`
[17:26:35.910]             `<<-` <- base::`<<-`
[17:26:35.910]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:35.910]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:35.910]                   3L)]
[17:26:35.910]             }
[17:26:35.910]             function(cond) {
[17:26:35.910]                 is_error <- inherits(cond, "error")
[17:26:35.910]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:35.910]                   NULL)
[17:26:35.910]                 if (is_error) {
[17:26:35.910]                   sessionInformation <- function() {
[17:26:35.910]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:35.910]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:35.910]                       search = base::search(), system = base::Sys.info())
[17:26:35.910]                   }
[17:26:35.910]                   ...future.conditions[[length(...future.conditions) + 
[17:26:35.910]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:35.910]                     cond$call), session = sessionInformation(), 
[17:26:35.910]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:35.910]                   signalCondition(cond)
[17:26:35.910]                 }
[17:26:35.910]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:35.910]                 "immediateCondition"))) {
[17:26:35.910]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:35.910]                   ...future.conditions[[length(...future.conditions) + 
[17:26:35.910]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:35.910]                   if (TRUE && !signal) {
[17:26:35.910]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:35.910]                     {
[17:26:35.910]                       inherits <- base::inherits
[17:26:35.910]                       invokeRestart <- base::invokeRestart
[17:26:35.910]                       is.null <- base::is.null
[17:26:35.910]                       muffled <- FALSE
[17:26:35.910]                       if (inherits(cond, "message")) {
[17:26:35.910]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:35.910]                         if (muffled) 
[17:26:35.910]                           invokeRestart("muffleMessage")
[17:26:35.910]                       }
[17:26:35.910]                       else if (inherits(cond, "warning")) {
[17:26:35.910]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:35.910]                         if (muffled) 
[17:26:35.910]                           invokeRestart("muffleWarning")
[17:26:35.910]                       }
[17:26:35.910]                       else if (inherits(cond, "condition")) {
[17:26:35.910]                         if (!is.null(pattern)) {
[17:26:35.910]                           computeRestarts <- base::computeRestarts
[17:26:35.910]                           grepl <- base::grepl
[17:26:35.910]                           restarts <- computeRestarts(cond)
[17:26:35.910]                           for (restart in restarts) {
[17:26:35.910]                             name <- restart$name
[17:26:35.910]                             if (is.null(name)) 
[17:26:35.910]                               next
[17:26:35.910]                             if (!grepl(pattern, name)) 
[17:26:35.910]                               next
[17:26:35.910]                             invokeRestart(restart)
[17:26:35.910]                             muffled <- TRUE
[17:26:35.910]                             break
[17:26:35.910]                           }
[17:26:35.910]                         }
[17:26:35.910]                       }
[17:26:35.910]                       invisible(muffled)
[17:26:35.910]                     }
[17:26:35.910]                     muffleCondition(cond, pattern = "^muffle")
[17:26:35.910]                   }
[17:26:35.910]                 }
[17:26:35.910]                 else {
[17:26:35.910]                   if (TRUE) {
[17:26:35.910]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:35.910]                     {
[17:26:35.910]                       inherits <- base::inherits
[17:26:35.910]                       invokeRestart <- base::invokeRestart
[17:26:35.910]                       is.null <- base::is.null
[17:26:35.910]                       muffled <- FALSE
[17:26:35.910]                       if (inherits(cond, "message")) {
[17:26:35.910]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:35.910]                         if (muffled) 
[17:26:35.910]                           invokeRestart("muffleMessage")
[17:26:35.910]                       }
[17:26:35.910]                       else if (inherits(cond, "warning")) {
[17:26:35.910]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:35.910]                         if (muffled) 
[17:26:35.910]                           invokeRestart("muffleWarning")
[17:26:35.910]                       }
[17:26:35.910]                       else if (inherits(cond, "condition")) {
[17:26:35.910]                         if (!is.null(pattern)) {
[17:26:35.910]                           computeRestarts <- base::computeRestarts
[17:26:35.910]                           grepl <- base::grepl
[17:26:35.910]                           restarts <- computeRestarts(cond)
[17:26:35.910]                           for (restart in restarts) {
[17:26:35.910]                             name <- restart$name
[17:26:35.910]                             if (is.null(name)) 
[17:26:35.910]                               next
[17:26:35.910]                             if (!grepl(pattern, name)) 
[17:26:35.910]                               next
[17:26:35.910]                             invokeRestart(restart)
[17:26:35.910]                             muffled <- TRUE
[17:26:35.910]                             break
[17:26:35.910]                           }
[17:26:35.910]                         }
[17:26:35.910]                       }
[17:26:35.910]                       invisible(muffled)
[17:26:35.910]                     }
[17:26:35.910]                     muffleCondition(cond, pattern = "^muffle")
[17:26:35.910]                   }
[17:26:35.910]                 }
[17:26:35.910]             }
[17:26:35.910]         }))
[17:26:35.910]     }, error = function(ex) {
[17:26:35.910]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:35.910]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:35.910]                 ...future.rng), started = ...future.startTime, 
[17:26:35.910]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:35.910]             version = "1.8"), class = "FutureResult")
[17:26:35.910]     }, finally = {
[17:26:35.910]         if (!identical(...future.workdir, getwd())) 
[17:26:35.910]             setwd(...future.workdir)
[17:26:35.910]         {
[17:26:35.910]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:35.910]                 ...future.oldOptions$nwarnings <- NULL
[17:26:35.910]             }
[17:26:35.910]             base::options(...future.oldOptions)
[17:26:35.910]             if (.Platform$OS.type == "windows") {
[17:26:35.910]                 old_names <- names(...future.oldEnvVars)
[17:26:35.910]                 envs <- base::Sys.getenv()
[17:26:35.910]                 names <- names(envs)
[17:26:35.910]                 common <- intersect(names, old_names)
[17:26:35.910]                 added <- setdiff(names, old_names)
[17:26:35.910]                 removed <- setdiff(old_names, names)
[17:26:35.910]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:35.910]                   envs[common]]
[17:26:35.910]                 NAMES <- toupper(changed)
[17:26:35.910]                 args <- list()
[17:26:35.910]                 for (kk in seq_along(NAMES)) {
[17:26:35.910]                   name <- changed[[kk]]
[17:26:35.910]                   NAME <- NAMES[[kk]]
[17:26:35.910]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:35.910]                     next
[17:26:35.910]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:35.910]                 }
[17:26:35.910]                 NAMES <- toupper(added)
[17:26:35.910]                 for (kk in seq_along(NAMES)) {
[17:26:35.910]                   name <- added[[kk]]
[17:26:35.910]                   NAME <- NAMES[[kk]]
[17:26:35.910]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:35.910]                     next
[17:26:35.910]                   args[[name]] <- ""
[17:26:35.910]                 }
[17:26:35.910]                 NAMES <- toupper(removed)
[17:26:35.910]                 for (kk in seq_along(NAMES)) {
[17:26:35.910]                   name <- removed[[kk]]
[17:26:35.910]                   NAME <- NAMES[[kk]]
[17:26:35.910]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:35.910]                     next
[17:26:35.910]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:35.910]                 }
[17:26:35.910]                 if (length(args) > 0) 
[17:26:35.910]                   base::do.call(base::Sys.setenv, args = args)
[17:26:35.910]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:35.910]             }
[17:26:35.910]             else {
[17:26:35.910]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:35.910]             }
[17:26:35.910]             {
[17:26:35.910]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:35.910]                   0L) {
[17:26:35.910]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:35.910]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:35.910]                   base::options(opts)
[17:26:35.910]                 }
[17:26:35.910]                 {
[17:26:35.910]                   {
[17:26:35.910]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:35.910]                     NULL
[17:26:35.910]                   }
[17:26:35.910]                   options(future.plan = NULL)
[17:26:35.910]                   if (is.na(NA_character_)) 
[17:26:35.910]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:35.910]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:35.910]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:35.910]                     .init = FALSE)
[17:26:35.910]                 }
[17:26:35.910]             }
[17:26:35.910]         }
[17:26:35.910]     })
[17:26:35.910]     if (TRUE) {
[17:26:35.910]         base::sink(type = "output", split = FALSE)
[17:26:35.910]         if (TRUE) {
[17:26:35.910]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:35.910]         }
[17:26:35.910]         else {
[17:26:35.910]             ...future.result["stdout"] <- base::list(NULL)
[17:26:35.910]         }
[17:26:35.910]         base::close(...future.stdout)
[17:26:35.910]         ...future.stdout <- NULL
[17:26:35.910]     }
[17:26:35.910]     ...future.result$conditions <- ...future.conditions
[17:26:35.910]     ...future.result$finished <- base::Sys.time()
[17:26:35.910]     ...future.result
[17:26:35.910] }
[17:26:35.916] MultisessionFuture started
[17:26:35.916] - Launch lazy future ... done
[17:26:35.916] run() for 'MultisessionFuture' ... done
[17:26:35.916] result() for ClusterFuture ...
[17:26:35.917] receiveMessageFromWorker() for ClusterFuture ...
[17:26:35.917] - Validating connection of MultisessionFuture
[17:26:35.932] - received message: FutureResult
[17:26:35.932] - Received FutureResult
[17:26:35.932] - Erased future from FutureRegistry
[17:26:35.932] result() for ClusterFuture ...
[17:26:35.932] - result already collected: FutureResult
[17:26:35.933] result() for ClusterFuture ... done
[17:26:35.933] signalConditions() ...
[17:26:35.933]  - include = 'immediateCondition'
[17:26:35.933]  - exclude = 
[17:26:35.933]  - resignal = FALSE
[17:26:35.934]  - Number of conditions: 1
[17:26:35.934] signalConditions() ... done
[17:26:35.934] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:35.934] result() for ClusterFuture ... done
[17:26:35.934] result() for ClusterFuture ...
[17:26:35.935] - result already collected: FutureResult
[17:26:35.935] result() for ClusterFuture ... done
[17:26:35.935] signalConditions() ...
[17:26:35.935]  - include = 'immediateCondition'
[17:26:35.935]  - exclude = 
[17:26:35.935]  - resignal = FALSE
[17:26:35.936]  - Number of conditions: 1
[17:26:35.936] signalConditions() ... done
[17:26:35.936] Future state: 'finished'
[17:26:35.936] result() for ClusterFuture ...
[17:26:35.936] - result already collected: FutureResult
[17:26:35.937] result() for ClusterFuture ... done
[17:26:35.937] signalConditions() ...
[17:26:35.937]  - include = 'condition'
[17:26:35.937]  - exclude = 'immediateCondition'
[17:26:35.937]  - resignal = TRUE
[17:26:35.940]  - Number of conditions: 1
[17:26:35.940]  - Condition #1: 'simpleError', 'error', 'condition'
[17:26:35.940] signalConditions() ... done
[17:26:35.941] getGlobalsAndPackages() ...
[17:26:35.941] Searching for globals...
[17:26:35.943] - globals found: [6] '{', 'if', '==', '%%', 'ii', 'stop'
[17:26:35.943] Searching for globals ... DONE
[17:26:35.943] Resolving globals: FALSE
[17:26:35.944] The total size of the 1 globals is 56 bytes (56 bytes)
[17:26:35.944] The total size of the 1 globals exported for future expression ('{; if (ii%%2 == 0); stop("Woops!"); ii; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'ii' (56 bytes of class 'numeric')
[17:26:35.945] - globals: [1] 'ii'
[17:26:35.945] 
[17:26:35.945] getGlobalsAndPackages() ... DONE
[17:26:35.945] run() for 'Future' ...
[17:26:35.945] - state: 'created'
[17:26:35.946] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:35.959] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:35.959] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:35.960]   - Field: 'node'
[17:26:35.960]   - Field: 'label'
[17:26:35.960]   - Field: 'local'
[17:26:35.960]   - Field: 'owner'
[17:26:35.960]   - Field: 'envir'
[17:26:35.961]   - Field: 'workers'
[17:26:35.961]   - Field: 'packages'
[17:26:35.961]   - Field: 'gc'
[17:26:35.961]   - Field: 'conditions'
[17:26:35.961]   - Field: 'persistent'
[17:26:35.961]   - Field: 'expr'
[17:26:35.962]   - Field: 'uuid'
[17:26:35.962]   - Field: 'seed'
[17:26:35.962]   - Field: 'version'
[17:26:35.962]   - Field: 'result'
[17:26:35.962]   - Field: 'asynchronous'
[17:26:35.962]   - Field: 'calls'
[17:26:35.963]   - Field: 'globals'
[17:26:35.963]   - Field: 'stdout'
[17:26:35.963]   - Field: 'earlySignal'
[17:26:35.963]   - Field: 'lazy'
[17:26:35.963]   - Field: 'state'
[17:26:35.963] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:35.964] - Launch lazy future ...
[17:26:35.964] Packages needed by the future expression (n = 0): <none>
[17:26:35.964] Packages needed by future strategies (n = 0): <none>
[17:26:35.965] {
[17:26:35.965]     {
[17:26:35.965]         {
[17:26:35.965]             ...future.startTime <- base::Sys.time()
[17:26:35.965]             {
[17:26:35.965]                 {
[17:26:35.965]                   {
[17:26:35.965]                     {
[17:26:35.965]                       base::local({
[17:26:35.965]                         has_future <- base::requireNamespace("future", 
[17:26:35.965]                           quietly = TRUE)
[17:26:35.965]                         if (has_future) {
[17:26:35.965]                           ns <- base::getNamespace("future")
[17:26:35.965]                           version <- ns[[".package"]][["version"]]
[17:26:35.965]                           if (is.null(version)) 
[17:26:35.965]                             version <- utils::packageVersion("future")
[17:26:35.965]                         }
[17:26:35.965]                         else {
[17:26:35.965]                           version <- NULL
[17:26:35.965]                         }
[17:26:35.965]                         if (!has_future || version < "1.8.0") {
[17:26:35.965]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:35.965]                             "", base::R.version$version.string), 
[17:26:35.965]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:35.965]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:35.965]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:35.965]                               "release", "version")], collapse = " "), 
[17:26:35.965]                             hostname = base::Sys.info()[["nodename"]])
[17:26:35.965]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:35.965]                             info)
[17:26:35.965]                           info <- base::paste(info, collapse = "; ")
[17:26:35.965]                           if (!has_future) {
[17:26:35.965]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:35.965]                               info)
[17:26:35.965]                           }
[17:26:35.965]                           else {
[17:26:35.965]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:35.965]                               info, version)
[17:26:35.965]                           }
[17:26:35.965]                           base::stop(msg)
[17:26:35.965]                         }
[17:26:35.965]                       })
[17:26:35.965]                     }
[17:26:35.965]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:35.965]                     base::options(mc.cores = 1L)
[17:26:35.965]                   }
[17:26:35.965]                   ...future.strategy.old <- future::plan("list")
[17:26:35.965]                   options(future.plan = NULL)
[17:26:35.965]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:35.965]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:35.965]                 }
[17:26:35.965]                 ...future.workdir <- getwd()
[17:26:35.965]             }
[17:26:35.965]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:35.965]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:35.965]         }
[17:26:35.965]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:35.965]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:35.965]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:35.965]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:35.965]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:35.965]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:35.965]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:35.965]             base::names(...future.oldOptions))
[17:26:35.965]     }
[17:26:35.965]     if (FALSE) {
[17:26:35.965]     }
[17:26:35.965]     else {
[17:26:35.965]         if (TRUE) {
[17:26:35.965]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:35.965]                 open = "w")
[17:26:35.965]         }
[17:26:35.965]         else {
[17:26:35.965]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:35.965]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:35.965]         }
[17:26:35.965]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:35.965]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:35.965]             base::sink(type = "output", split = FALSE)
[17:26:35.965]             base::close(...future.stdout)
[17:26:35.965]         }, add = TRUE)
[17:26:35.965]     }
[17:26:35.965]     ...future.frame <- base::sys.nframe()
[17:26:35.965]     ...future.conditions <- base::list()
[17:26:35.965]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:35.965]     if (FALSE) {
[17:26:35.965]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:35.965]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:35.965]     }
[17:26:35.965]     ...future.result <- base::tryCatch({
[17:26:35.965]         base::withCallingHandlers({
[17:26:35.965]             ...future.value <- base::withVisible(base::local({
[17:26:35.965]                 ...future.makeSendCondition <- base::local({
[17:26:35.965]                   sendCondition <- NULL
[17:26:35.965]                   function(frame = 1L) {
[17:26:35.965]                     if (is.function(sendCondition)) 
[17:26:35.965]                       return(sendCondition)
[17:26:35.965]                     ns <- getNamespace("parallel")
[17:26:35.965]                     if (exists("sendData", mode = "function", 
[17:26:35.965]                       envir = ns)) {
[17:26:35.965]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:35.965]                         envir = ns)
[17:26:35.965]                       envir <- sys.frame(frame)
[17:26:35.965]                       master <- NULL
[17:26:35.965]                       while (!identical(envir, .GlobalEnv) && 
[17:26:35.965]                         !identical(envir, emptyenv())) {
[17:26:35.965]                         if (exists("master", mode = "list", envir = envir, 
[17:26:35.965]                           inherits = FALSE)) {
[17:26:35.965]                           master <- get("master", mode = "list", 
[17:26:35.965]                             envir = envir, inherits = FALSE)
[17:26:35.965]                           if (inherits(master, c("SOCKnode", 
[17:26:35.965]                             "SOCK0node"))) {
[17:26:35.965]                             sendCondition <<- function(cond) {
[17:26:35.965]                               data <- list(type = "VALUE", value = cond, 
[17:26:35.965]                                 success = TRUE)
[17:26:35.965]                               parallel_sendData(master, data)
[17:26:35.965]                             }
[17:26:35.965]                             return(sendCondition)
[17:26:35.965]                           }
[17:26:35.965]                         }
[17:26:35.965]                         frame <- frame + 1L
[17:26:35.965]                         envir <- sys.frame(frame)
[17:26:35.965]                       }
[17:26:35.965]                     }
[17:26:35.965]                     sendCondition <<- function(cond) NULL
[17:26:35.965]                   }
[17:26:35.965]                 })
[17:26:35.965]                 withCallingHandlers({
[17:26:35.965]                   {
[17:26:35.965]                     if (ii%%2 == 0) 
[17:26:35.965]                       stop("Woops!")
[17:26:35.965]                     ii
[17:26:35.965]                   }
[17:26:35.965]                 }, immediateCondition = function(cond) {
[17:26:35.965]                   sendCondition <- ...future.makeSendCondition()
[17:26:35.965]                   sendCondition(cond)
[17:26:35.965]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:35.965]                   {
[17:26:35.965]                     inherits <- base::inherits
[17:26:35.965]                     invokeRestart <- base::invokeRestart
[17:26:35.965]                     is.null <- base::is.null
[17:26:35.965]                     muffled <- FALSE
[17:26:35.965]                     if (inherits(cond, "message")) {
[17:26:35.965]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:35.965]                       if (muffled) 
[17:26:35.965]                         invokeRestart("muffleMessage")
[17:26:35.965]                     }
[17:26:35.965]                     else if (inherits(cond, "warning")) {
[17:26:35.965]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:35.965]                       if (muffled) 
[17:26:35.965]                         invokeRestart("muffleWarning")
[17:26:35.965]                     }
[17:26:35.965]                     else if (inherits(cond, "condition")) {
[17:26:35.965]                       if (!is.null(pattern)) {
[17:26:35.965]                         computeRestarts <- base::computeRestarts
[17:26:35.965]                         grepl <- base::grepl
[17:26:35.965]                         restarts <- computeRestarts(cond)
[17:26:35.965]                         for (restart in restarts) {
[17:26:35.965]                           name <- restart$name
[17:26:35.965]                           if (is.null(name)) 
[17:26:35.965]                             next
[17:26:35.965]                           if (!grepl(pattern, name)) 
[17:26:35.965]                             next
[17:26:35.965]                           invokeRestart(restart)
[17:26:35.965]                           muffled <- TRUE
[17:26:35.965]                           break
[17:26:35.965]                         }
[17:26:35.965]                       }
[17:26:35.965]                     }
[17:26:35.965]                     invisible(muffled)
[17:26:35.965]                   }
[17:26:35.965]                   muffleCondition(cond)
[17:26:35.965]                 })
[17:26:35.965]             }))
[17:26:35.965]             future::FutureResult(value = ...future.value$value, 
[17:26:35.965]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:35.965]                   ...future.rng), globalenv = if (FALSE) 
[17:26:35.965]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:35.965]                     ...future.globalenv.names))
[17:26:35.965]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:35.965]         }, condition = base::local({
[17:26:35.965]             c <- base::c
[17:26:35.965]             inherits <- base::inherits
[17:26:35.965]             invokeRestart <- base::invokeRestart
[17:26:35.965]             length <- base::length
[17:26:35.965]             list <- base::list
[17:26:35.965]             seq.int <- base::seq.int
[17:26:35.965]             signalCondition <- base::signalCondition
[17:26:35.965]             sys.calls <- base::sys.calls
[17:26:35.965]             `[[` <- base::`[[`
[17:26:35.965]             `+` <- base::`+`
[17:26:35.965]             `<<-` <- base::`<<-`
[17:26:35.965]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:35.965]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:35.965]                   3L)]
[17:26:35.965]             }
[17:26:35.965]             function(cond) {
[17:26:35.965]                 is_error <- inherits(cond, "error")
[17:26:35.965]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:35.965]                   NULL)
[17:26:35.965]                 if (is_error) {
[17:26:35.965]                   sessionInformation <- function() {
[17:26:35.965]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:35.965]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:35.965]                       search = base::search(), system = base::Sys.info())
[17:26:35.965]                   }
[17:26:35.965]                   ...future.conditions[[length(...future.conditions) + 
[17:26:35.965]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:35.965]                     cond$call), session = sessionInformation(), 
[17:26:35.965]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:35.965]                   signalCondition(cond)
[17:26:35.965]                 }
[17:26:35.965]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:35.965]                 "immediateCondition"))) {
[17:26:35.965]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:35.965]                   ...future.conditions[[length(...future.conditions) + 
[17:26:35.965]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:35.965]                   if (TRUE && !signal) {
[17:26:35.965]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:35.965]                     {
[17:26:35.965]                       inherits <- base::inherits
[17:26:35.965]                       invokeRestart <- base::invokeRestart
[17:26:35.965]                       is.null <- base::is.null
[17:26:35.965]                       muffled <- FALSE
[17:26:35.965]                       if (inherits(cond, "message")) {
[17:26:35.965]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:35.965]                         if (muffled) 
[17:26:35.965]                           invokeRestart("muffleMessage")
[17:26:35.965]                       }
[17:26:35.965]                       else if (inherits(cond, "warning")) {
[17:26:35.965]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:35.965]                         if (muffled) 
[17:26:35.965]                           invokeRestart("muffleWarning")
[17:26:35.965]                       }
[17:26:35.965]                       else if (inherits(cond, "condition")) {
[17:26:35.965]                         if (!is.null(pattern)) {
[17:26:35.965]                           computeRestarts <- base::computeRestarts
[17:26:35.965]                           grepl <- base::grepl
[17:26:35.965]                           restarts <- computeRestarts(cond)
[17:26:35.965]                           for (restart in restarts) {
[17:26:35.965]                             name <- restart$name
[17:26:35.965]                             if (is.null(name)) 
[17:26:35.965]                               next
[17:26:35.965]                             if (!grepl(pattern, name)) 
[17:26:35.965]                               next
[17:26:35.965]                             invokeRestart(restart)
[17:26:35.965]                             muffled <- TRUE
[17:26:35.965]                             break
[17:26:35.965]                           }
[17:26:35.965]                         }
[17:26:35.965]                       }
[17:26:35.965]                       invisible(muffled)
[17:26:35.965]                     }
[17:26:35.965]                     muffleCondition(cond, pattern = "^muffle")
[17:26:35.965]                   }
[17:26:35.965]                 }
[17:26:35.965]                 else {
[17:26:35.965]                   if (TRUE) {
[17:26:35.965]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:35.965]                     {
[17:26:35.965]                       inherits <- base::inherits
[17:26:35.965]                       invokeRestart <- base::invokeRestart
[17:26:35.965]                       is.null <- base::is.null
[17:26:35.965]                       muffled <- FALSE
[17:26:35.965]                       if (inherits(cond, "message")) {
[17:26:35.965]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:35.965]                         if (muffled) 
[17:26:35.965]                           invokeRestart("muffleMessage")
[17:26:35.965]                       }
[17:26:35.965]                       else if (inherits(cond, "warning")) {
[17:26:35.965]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:35.965]                         if (muffled) 
[17:26:35.965]                           invokeRestart("muffleWarning")
[17:26:35.965]                       }
[17:26:35.965]                       else if (inherits(cond, "condition")) {
[17:26:35.965]                         if (!is.null(pattern)) {
[17:26:35.965]                           computeRestarts <- base::computeRestarts
[17:26:35.965]                           grepl <- base::grepl
[17:26:35.965]                           restarts <- computeRestarts(cond)
[17:26:35.965]                           for (restart in restarts) {
[17:26:35.965]                             name <- restart$name
[17:26:35.965]                             if (is.null(name)) 
[17:26:35.965]                               next
[17:26:35.965]                             if (!grepl(pattern, name)) 
[17:26:35.965]                               next
[17:26:35.965]                             invokeRestart(restart)
[17:26:35.965]                             muffled <- TRUE
[17:26:35.965]                             break
[17:26:35.965]                           }
[17:26:35.965]                         }
[17:26:35.965]                       }
[17:26:35.965]                       invisible(muffled)
[17:26:35.965]                     }
[17:26:35.965]                     muffleCondition(cond, pattern = "^muffle")
[17:26:35.965]                   }
[17:26:35.965]                 }
[17:26:35.965]             }
[17:26:35.965]         }))
[17:26:35.965]     }, error = function(ex) {
[17:26:35.965]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:35.965]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:35.965]                 ...future.rng), started = ...future.startTime, 
[17:26:35.965]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:35.965]             version = "1.8"), class = "FutureResult")
[17:26:35.965]     }, finally = {
[17:26:35.965]         if (!identical(...future.workdir, getwd())) 
[17:26:35.965]             setwd(...future.workdir)
[17:26:35.965]         {
[17:26:35.965]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:35.965]                 ...future.oldOptions$nwarnings <- NULL
[17:26:35.965]             }
[17:26:35.965]             base::options(...future.oldOptions)
[17:26:35.965]             if (.Platform$OS.type == "windows") {
[17:26:35.965]                 old_names <- names(...future.oldEnvVars)
[17:26:35.965]                 envs <- base::Sys.getenv()
[17:26:35.965]                 names <- names(envs)
[17:26:35.965]                 common <- intersect(names, old_names)
[17:26:35.965]                 added <- setdiff(names, old_names)
[17:26:35.965]                 removed <- setdiff(old_names, names)
[17:26:35.965]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:35.965]                   envs[common]]
[17:26:35.965]                 NAMES <- toupper(changed)
[17:26:35.965]                 args <- list()
[17:26:35.965]                 for (kk in seq_along(NAMES)) {
[17:26:35.965]                   name <- changed[[kk]]
[17:26:35.965]                   NAME <- NAMES[[kk]]
[17:26:35.965]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:35.965]                     next
[17:26:35.965]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:35.965]                 }
[17:26:35.965]                 NAMES <- toupper(added)
[17:26:35.965]                 for (kk in seq_along(NAMES)) {
[17:26:35.965]                   name <- added[[kk]]
[17:26:35.965]                   NAME <- NAMES[[kk]]
[17:26:35.965]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:35.965]                     next
[17:26:35.965]                   args[[name]] <- ""
[17:26:35.965]                 }
[17:26:35.965]                 NAMES <- toupper(removed)
[17:26:35.965]                 for (kk in seq_along(NAMES)) {
[17:26:35.965]                   name <- removed[[kk]]
[17:26:35.965]                   NAME <- NAMES[[kk]]
[17:26:35.965]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:35.965]                     next
[17:26:35.965]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:35.965]                 }
[17:26:35.965]                 if (length(args) > 0) 
[17:26:35.965]                   base::do.call(base::Sys.setenv, args = args)
[17:26:35.965]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:35.965]             }
[17:26:35.965]             else {
[17:26:35.965]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:35.965]             }
[17:26:35.965]             {
[17:26:35.965]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:35.965]                   0L) {
[17:26:35.965]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:35.965]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:35.965]                   base::options(opts)
[17:26:35.965]                 }
[17:26:35.965]                 {
[17:26:35.965]                   {
[17:26:35.965]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:35.965]                     NULL
[17:26:35.965]                   }
[17:26:35.965]                   options(future.plan = NULL)
[17:26:35.965]                   if (is.na(NA_character_)) 
[17:26:35.965]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:35.965]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:35.965]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:35.965]                     .init = FALSE)
[17:26:35.965]                 }
[17:26:35.965]             }
[17:26:35.965]         }
[17:26:35.965]     })
[17:26:35.965]     if (TRUE) {
[17:26:35.965]         base::sink(type = "output", split = FALSE)
[17:26:35.965]         if (TRUE) {
[17:26:35.965]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:35.965]         }
[17:26:35.965]         else {
[17:26:35.965]             ...future.result["stdout"] <- base::list(NULL)
[17:26:35.965]         }
[17:26:35.965]         base::close(...future.stdout)
[17:26:35.965]         ...future.stdout <- NULL
[17:26:35.965]     }
[17:26:35.965]     ...future.result$conditions <- ...future.conditions
[17:26:35.965]     ...future.result$finished <- base::Sys.time()
[17:26:35.965]     ...future.result
[17:26:35.965] }
[17:26:35.970] Exporting 1 global objects (56 bytes) to cluster node #1 ...
[17:26:35.970] Exporting 'ii' (56 bytes) to cluster node #1 ...
[17:26:35.970] Exporting 'ii' (56 bytes) to cluster node #1 ... DONE
[17:26:35.971] Exporting 1 global objects (56 bytes) to cluster node #1 ... DONE
[17:26:35.971] MultisessionFuture started
[17:26:35.971] - Launch lazy future ... done
[17:26:35.972] run() for 'MultisessionFuture' ... done
[17:26:35.972] getGlobalsAndPackages() ...
[17:26:35.972] Searching for globals...
[17:26:35.974] - globals found: [6] '{', 'if', '==', '%%', 'ii', 'stop'
[17:26:35.974] Searching for globals ... DONE
[17:26:35.974] Resolving globals: FALSE
[17:26:35.975] The total size of the 1 globals is 56 bytes (56 bytes)
[17:26:35.975] The total size of the 1 globals exported for future expression ('{; if (ii%%2 == 0); stop("Woops!"); ii; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'ii' (56 bytes of class 'numeric')
[17:26:35.976] - globals: [1] 'ii'
[17:26:35.976] 
[17:26:35.976] getGlobalsAndPackages() ... DONE
[17:26:35.976] run() for 'Future' ...
[17:26:35.977] - state: 'created'
[17:26:35.977] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:35.990] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:35.991] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:35.991]   - Field: 'node'
[17:26:35.991]   - Field: 'label'
[17:26:35.991]   - Field: 'local'
[17:26:35.991]   - Field: 'owner'
[17:26:35.992]   - Field: 'envir'
[17:26:35.992]   - Field: 'workers'
[17:26:35.992]   - Field: 'packages'
[17:26:35.992]   - Field: 'gc'
[17:26:35.992]   - Field: 'conditions'
[17:26:35.992]   - Field: 'persistent'
[17:26:35.993]   - Field: 'expr'
[17:26:35.993]   - Field: 'uuid'
[17:26:35.993]   - Field: 'seed'
[17:26:35.993]   - Field: 'version'
[17:26:35.993]   - Field: 'result'
[17:26:35.994]   - Field: 'asynchronous'
[17:26:35.994]   - Field: 'calls'
[17:26:35.994]   - Field: 'globals'
[17:26:35.994]   - Field: 'stdout'
[17:26:35.994]   - Field: 'earlySignal'
[17:26:35.994]   - Field: 'lazy'
[17:26:35.995]   - Field: 'state'
[17:26:35.995] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:35.995] - Launch lazy future ...
[17:26:35.995] Packages needed by the future expression (n = 0): <none>
[17:26:35.995] Packages needed by future strategies (n = 0): <none>
[17:26:35.996] {
[17:26:35.996]     {
[17:26:35.996]         {
[17:26:35.996]             ...future.startTime <- base::Sys.time()
[17:26:35.996]             {
[17:26:35.996]                 {
[17:26:35.996]                   {
[17:26:35.996]                     {
[17:26:35.996]                       base::local({
[17:26:35.996]                         has_future <- base::requireNamespace("future", 
[17:26:35.996]                           quietly = TRUE)
[17:26:35.996]                         if (has_future) {
[17:26:35.996]                           ns <- base::getNamespace("future")
[17:26:35.996]                           version <- ns[[".package"]][["version"]]
[17:26:35.996]                           if (is.null(version)) 
[17:26:35.996]                             version <- utils::packageVersion("future")
[17:26:35.996]                         }
[17:26:35.996]                         else {
[17:26:35.996]                           version <- NULL
[17:26:35.996]                         }
[17:26:35.996]                         if (!has_future || version < "1.8.0") {
[17:26:35.996]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:35.996]                             "", base::R.version$version.string), 
[17:26:35.996]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:35.996]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:35.996]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:35.996]                               "release", "version")], collapse = " "), 
[17:26:35.996]                             hostname = base::Sys.info()[["nodename"]])
[17:26:35.996]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:35.996]                             info)
[17:26:35.996]                           info <- base::paste(info, collapse = "; ")
[17:26:35.996]                           if (!has_future) {
[17:26:35.996]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:35.996]                               info)
[17:26:35.996]                           }
[17:26:35.996]                           else {
[17:26:35.996]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:35.996]                               info, version)
[17:26:35.996]                           }
[17:26:35.996]                           base::stop(msg)
[17:26:35.996]                         }
[17:26:35.996]                       })
[17:26:35.996]                     }
[17:26:35.996]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:35.996]                     base::options(mc.cores = 1L)
[17:26:35.996]                   }
[17:26:35.996]                   ...future.strategy.old <- future::plan("list")
[17:26:35.996]                   options(future.plan = NULL)
[17:26:35.996]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:35.996]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:35.996]                 }
[17:26:35.996]                 ...future.workdir <- getwd()
[17:26:35.996]             }
[17:26:35.996]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:35.996]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:35.996]         }
[17:26:35.996]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:35.996]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:35.996]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:35.996]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:35.996]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:35.996]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:35.996]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:35.996]             base::names(...future.oldOptions))
[17:26:35.996]     }
[17:26:35.996]     if (FALSE) {
[17:26:35.996]     }
[17:26:35.996]     else {
[17:26:35.996]         if (TRUE) {
[17:26:35.996]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:35.996]                 open = "w")
[17:26:35.996]         }
[17:26:35.996]         else {
[17:26:35.996]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:35.996]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:35.996]         }
[17:26:35.996]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:35.996]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:35.996]             base::sink(type = "output", split = FALSE)
[17:26:35.996]             base::close(...future.stdout)
[17:26:35.996]         }, add = TRUE)
[17:26:35.996]     }
[17:26:35.996]     ...future.frame <- base::sys.nframe()
[17:26:35.996]     ...future.conditions <- base::list()
[17:26:35.996]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:35.996]     if (FALSE) {
[17:26:35.996]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:35.996]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:35.996]     }
[17:26:35.996]     ...future.result <- base::tryCatch({
[17:26:35.996]         base::withCallingHandlers({
[17:26:35.996]             ...future.value <- base::withVisible(base::local({
[17:26:35.996]                 ...future.makeSendCondition <- base::local({
[17:26:35.996]                   sendCondition <- NULL
[17:26:35.996]                   function(frame = 1L) {
[17:26:35.996]                     if (is.function(sendCondition)) 
[17:26:35.996]                       return(sendCondition)
[17:26:35.996]                     ns <- getNamespace("parallel")
[17:26:35.996]                     if (exists("sendData", mode = "function", 
[17:26:35.996]                       envir = ns)) {
[17:26:35.996]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:35.996]                         envir = ns)
[17:26:35.996]                       envir <- sys.frame(frame)
[17:26:35.996]                       master <- NULL
[17:26:35.996]                       while (!identical(envir, .GlobalEnv) && 
[17:26:35.996]                         !identical(envir, emptyenv())) {
[17:26:35.996]                         if (exists("master", mode = "list", envir = envir, 
[17:26:35.996]                           inherits = FALSE)) {
[17:26:35.996]                           master <- get("master", mode = "list", 
[17:26:35.996]                             envir = envir, inherits = FALSE)
[17:26:35.996]                           if (inherits(master, c("SOCKnode", 
[17:26:35.996]                             "SOCK0node"))) {
[17:26:35.996]                             sendCondition <<- function(cond) {
[17:26:35.996]                               data <- list(type = "VALUE", value = cond, 
[17:26:35.996]                                 success = TRUE)
[17:26:35.996]                               parallel_sendData(master, data)
[17:26:35.996]                             }
[17:26:35.996]                             return(sendCondition)
[17:26:35.996]                           }
[17:26:35.996]                         }
[17:26:35.996]                         frame <- frame + 1L
[17:26:35.996]                         envir <- sys.frame(frame)
[17:26:35.996]                       }
[17:26:35.996]                     }
[17:26:35.996]                     sendCondition <<- function(cond) NULL
[17:26:35.996]                   }
[17:26:35.996]                 })
[17:26:35.996]                 withCallingHandlers({
[17:26:35.996]                   {
[17:26:35.996]                     if (ii%%2 == 0) 
[17:26:35.996]                       stop("Woops!")
[17:26:35.996]                     ii
[17:26:35.996]                   }
[17:26:35.996]                 }, immediateCondition = function(cond) {
[17:26:35.996]                   sendCondition <- ...future.makeSendCondition()
[17:26:35.996]                   sendCondition(cond)
[17:26:35.996]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:35.996]                   {
[17:26:35.996]                     inherits <- base::inherits
[17:26:35.996]                     invokeRestart <- base::invokeRestart
[17:26:35.996]                     is.null <- base::is.null
[17:26:35.996]                     muffled <- FALSE
[17:26:35.996]                     if (inherits(cond, "message")) {
[17:26:35.996]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:35.996]                       if (muffled) 
[17:26:35.996]                         invokeRestart("muffleMessage")
[17:26:35.996]                     }
[17:26:35.996]                     else if (inherits(cond, "warning")) {
[17:26:35.996]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:35.996]                       if (muffled) 
[17:26:35.996]                         invokeRestart("muffleWarning")
[17:26:35.996]                     }
[17:26:35.996]                     else if (inherits(cond, "condition")) {
[17:26:35.996]                       if (!is.null(pattern)) {
[17:26:35.996]                         computeRestarts <- base::computeRestarts
[17:26:35.996]                         grepl <- base::grepl
[17:26:35.996]                         restarts <- computeRestarts(cond)
[17:26:35.996]                         for (restart in restarts) {
[17:26:35.996]                           name <- restart$name
[17:26:35.996]                           if (is.null(name)) 
[17:26:35.996]                             next
[17:26:35.996]                           if (!grepl(pattern, name)) 
[17:26:35.996]                             next
[17:26:35.996]                           invokeRestart(restart)
[17:26:35.996]                           muffled <- TRUE
[17:26:35.996]                           break
[17:26:35.996]                         }
[17:26:35.996]                       }
[17:26:35.996]                     }
[17:26:35.996]                     invisible(muffled)
[17:26:35.996]                   }
[17:26:35.996]                   muffleCondition(cond)
[17:26:35.996]                 })
[17:26:35.996]             }))
[17:26:35.996]             future::FutureResult(value = ...future.value$value, 
[17:26:35.996]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:35.996]                   ...future.rng), globalenv = if (FALSE) 
[17:26:35.996]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:35.996]                     ...future.globalenv.names))
[17:26:35.996]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:35.996]         }, condition = base::local({
[17:26:35.996]             c <- base::c
[17:26:35.996]             inherits <- base::inherits
[17:26:35.996]             invokeRestart <- base::invokeRestart
[17:26:35.996]             length <- base::length
[17:26:35.996]             list <- base::list
[17:26:35.996]             seq.int <- base::seq.int
[17:26:35.996]             signalCondition <- base::signalCondition
[17:26:35.996]             sys.calls <- base::sys.calls
[17:26:35.996]             `[[` <- base::`[[`
[17:26:35.996]             `+` <- base::`+`
[17:26:35.996]             `<<-` <- base::`<<-`
[17:26:35.996]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:35.996]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:35.996]                   3L)]
[17:26:35.996]             }
[17:26:35.996]             function(cond) {
[17:26:35.996]                 is_error <- inherits(cond, "error")
[17:26:35.996]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:35.996]                   NULL)
[17:26:35.996]                 if (is_error) {
[17:26:35.996]                   sessionInformation <- function() {
[17:26:35.996]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:35.996]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:35.996]                       search = base::search(), system = base::Sys.info())
[17:26:35.996]                   }
[17:26:35.996]                   ...future.conditions[[length(...future.conditions) + 
[17:26:35.996]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:35.996]                     cond$call), session = sessionInformation(), 
[17:26:35.996]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:35.996]                   signalCondition(cond)
[17:26:35.996]                 }
[17:26:35.996]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:35.996]                 "immediateCondition"))) {
[17:26:35.996]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:35.996]                   ...future.conditions[[length(...future.conditions) + 
[17:26:35.996]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:35.996]                   if (TRUE && !signal) {
[17:26:35.996]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:35.996]                     {
[17:26:35.996]                       inherits <- base::inherits
[17:26:35.996]                       invokeRestart <- base::invokeRestart
[17:26:35.996]                       is.null <- base::is.null
[17:26:35.996]                       muffled <- FALSE
[17:26:35.996]                       if (inherits(cond, "message")) {
[17:26:35.996]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:35.996]                         if (muffled) 
[17:26:35.996]                           invokeRestart("muffleMessage")
[17:26:35.996]                       }
[17:26:35.996]                       else if (inherits(cond, "warning")) {
[17:26:35.996]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:35.996]                         if (muffled) 
[17:26:35.996]                           invokeRestart("muffleWarning")
[17:26:35.996]                       }
[17:26:35.996]                       else if (inherits(cond, "condition")) {
[17:26:35.996]                         if (!is.null(pattern)) {
[17:26:35.996]                           computeRestarts <- base::computeRestarts
[17:26:35.996]                           grepl <- base::grepl
[17:26:35.996]                           restarts <- computeRestarts(cond)
[17:26:35.996]                           for (restart in restarts) {
[17:26:35.996]                             name <- restart$name
[17:26:35.996]                             if (is.null(name)) 
[17:26:35.996]                               next
[17:26:35.996]                             if (!grepl(pattern, name)) 
[17:26:35.996]                               next
[17:26:35.996]                             invokeRestart(restart)
[17:26:35.996]                             muffled <- TRUE
[17:26:35.996]                             break
[17:26:35.996]                           }
[17:26:35.996]                         }
[17:26:35.996]                       }
[17:26:35.996]                       invisible(muffled)
[17:26:35.996]                     }
[17:26:35.996]                     muffleCondition(cond, pattern = "^muffle")
[17:26:35.996]                   }
[17:26:35.996]                 }
[17:26:35.996]                 else {
[17:26:35.996]                   if (TRUE) {
[17:26:35.996]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:35.996]                     {
[17:26:35.996]                       inherits <- base::inherits
[17:26:35.996]                       invokeRestart <- base::invokeRestart
[17:26:35.996]                       is.null <- base::is.null
[17:26:35.996]                       muffled <- FALSE
[17:26:35.996]                       if (inherits(cond, "message")) {
[17:26:35.996]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:35.996]                         if (muffled) 
[17:26:35.996]                           invokeRestart("muffleMessage")
[17:26:35.996]                       }
[17:26:35.996]                       else if (inherits(cond, "warning")) {
[17:26:35.996]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:35.996]                         if (muffled) 
[17:26:35.996]                           invokeRestart("muffleWarning")
[17:26:35.996]                       }
[17:26:35.996]                       else if (inherits(cond, "condition")) {
[17:26:35.996]                         if (!is.null(pattern)) {
[17:26:35.996]                           computeRestarts <- base::computeRestarts
[17:26:35.996]                           grepl <- base::grepl
[17:26:35.996]                           restarts <- computeRestarts(cond)
[17:26:35.996]                           for (restart in restarts) {
[17:26:35.996]                             name <- restart$name
[17:26:35.996]                             if (is.null(name)) 
[17:26:35.996]                               next
[17:26:35.996]                             if (!grepl(pattern, name)) 
[17:26:35.996]                               next
[17:26:35.996]                             invokeRestart(restart)
[17:26:35.996]                             muffled <- TRUE
[17:26:35.996]                             break
[17:26:35.996]                           }
[17:26:35.996]                         }
[17:26:35.996]                       }
[17:26:35.996]                       invisible(muffled)
[17:26:35.996]                     }
[17:26:35.996]                     muffleCondition(cond, pattern = "^muffle")
[17:26:35.996]                   }
[17:26:35.996]                 }
[17:26:35.996]             }
[17:26:35.996]         }))
[17:26:35.996]     }, error = function(ex) {
[17:26:35.996]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:35.996]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:35.996]                 ...future.rng), started = ...future.startTime, 
[17:26:35.996]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:35.996]             version = "1.8"), class = "FutureResult")
[17:26:35.996]     }, finally = {
[17:26:35.996]         if (!identical(...future.workdir, getwd())) 
[17:26:35.996]             setwd(...future.workdir)
[17:26:35.996]         {
[17:26:35.996]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:35.996]                 ...future.oldOptions$nwarnings <- NULL
[17:26:35.996]             }
[17:26:35.996]             base::options(...future.oldOptions)
[17:26:35.996]             if (.Platform$OS.type == "windows") {
[17:26:35.996]                 old_names <- names(...future.oldEnvVars)
[17:26:35.996]                 envs <- base::Sys.getenv()
[17:26:35.996]                 names <- names(envs)
[17:26:35.996]                 common <- intersect(names, old_names)
[17:26:35.996]                 added <- setdiff(names, old_names)
[17:26:35.996]                 removed <- setdiff(old_names, names)
[17:26:35.996]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:35.996]                   envs[common]]
[17:26:35.996]                 NAMES <- toupper(changed)
[17:26:35.996]                 args <- list()
[17:26:35.996]                 for (kk in seq_along(NAMES)) {
[17:26:35.996]                   name <- changed[[kk]]
[17:26:35.996]                   NAME <- NAMES[[kk]]
[17:26:35.996]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:35.996]                     next
[17:26:35.996]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:35.996]                 }
[17:26:35.996]                 NAMES <- toupper(added)
[17:26:35.996]                 for (kk in seq_along(NAMES)) {
[17:26:35.996]                   name <- added[[kk]]
[17:26:35.996]                   NAME <- NAMES[[kk]]
[17:26:35.996]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:35.996]                     next
[17:26:35.996]                   args[[name]] <- ""
[17:26:35.996]                 }
[17:26:35.996]                 NAMES <- toupper(removed)
[17:26:35.996]                 for (kk in seq_along(NAMES)) {
[17:26:35.996]                   name <- removed[[kk]]
[17:26:35.996]                   NAME <- NAMES[[kk]]
[17:26:35.996]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:35.996]                     next
[17:26:35.996]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:35.996]                 }
[17:26:35.996]                 if (length(args) > 0) 
[17:26:35.996]                   base::do.call(base::Sys.setenv, args = args)
[17:26:35.996]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:35.996]             }
[17:26:35.996]             else {
[17:26:35.996]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:35.996]             }
[17:26:35.996]             {
[17:26:35.996]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:35.996]                   0L) {
[17:26:35.996]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:35.996]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:35.996]                   base::options(opts)
[17:26:35.996]                 }
[17:26:35.996]                 {
[17:26:35.996]                   {
[17:26:35.996]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:35.996]                     NULL
[17:26:35.996]                   }
[17:26:35.996]                   options(future.plan = NULL)
[17:26:35.996]                   if (is.na(NA_character_)) 
[17:26:35.996]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:35.996]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:35.996]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:35.996]                     .init = FALSE)
[17:26:35.996]                 }
[17:26:35.996]             }
[17:26:35.996]         }
[17:26:35.996]     })
[17:26:35.996]     if (TRUE) {
[17:26:35.996]         base::sink(type = "output", split = FALSE)
[17:26:35.996]         if (TRUE) {
[17:26:35.996]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:35.996]         }
[17:26:35.996]         else {
[17:26:35.996]             ...future.result["stdout"] <- base::list(NULL)
[17:26:35.996]         }
[17:26:35.996]         base::close(...future.stdout)
[17:26:35.996]         ...future.stdout <- NULL
[17:26:35.996]     }
[17:26:35.996]     ...future.result$conditions <- ...future.conditions
[17:26:35.996]     ...future.result$finished <- base::Sys.time()
[17:26:35.996]     ...future.result
[17:26:35.996] }
[17:26:36.078] Exporting 1 global objects (56 bytes) to cluster node #2 ...
[17:26:36.078] Exporting 'ii' (56 bytes) to cluster node #2 ...
[17:26:36.079] Exporting 'ii' (56 bytes) to cluster node #2 ... DONE
[17:26:36.079] Exporting 1 global objects (56 bytes) to cluster node #2 ... DONE
[17:26:36.080] MultisessionFuture started
[17:26:36.080] - Launch lazy future ... done
[17:26:36.080] run() for 'MultisessionFuture' ... done
[17:26:36.080] getGlobalsAndPackages() ...
[17:26:36.081] Searching for globals...
[17:26:36.082] - globals found: [6] '{', 'if', '==', '%%', 'ii', 'stop'
[17:26:36.083] Searching for globals ... DONE
[17:26:36.083] Resolving globals: FALSE
[17:26:36.083] The total size of the 1 globals is 56 bytes (56 bytes)
[17:26:36.084] The total size of the 1 globals exported for future expression ('{; if (ii%%2 == 0); stop("Woops!"); ii; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'ii' (56 bytes of class 'numeric')
[17:26:36.084] - globals: [1] 'ii'
[17:26:36.084] 
[17:26:36.084] getGlobalsAndPackages() ... DONE
[17:26:36.085] run() for 'Future' ...
[17:26:36.085] - state: 'created'
[17:26:36.085] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:36.098] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:36.099] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:36.099]   - Field: 'node'
[17:26:36.099]   - Field: 'label'
[17:26:36.099]   - Field: 'local'
[17:26:36.099]   - Field: 'owner'
[17:26:36.100]   - Field: 'envir'
[17:26:36.100]   - Field: 'workers'
[17:26:36.100]   - Field: 'packages'
[17:26:36.100]   - Field: 'gc'
[17:26:36.100]   - Field: 'conditions'
[17:26:36.101]   - Field: 'persistent'
[17:26:36.101]   - Field: 'expr'
[17:26:36.101]   - Field: 'uuid'
[17:26:36.101]   - Field: 'seed'
[17:26:36.101]   - Field: 'version'
[17:26:36.101]   - Field: 'result'
[17:26:36.102]   - Field: 'asynchronous'
[17:26:36.102]   - Field: 'calls'
[17:26:36.102]   - Field: 'globals'
[17:26:36.102]   - Field: 'stdout'
[17:26:36.102]   - Field: 'earlySignal'
[17:26:36.102]   - Field: 'lazy'
[17:26:36.103]   - Field: 'state'
[17:26:36.103] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:36.103] - Launch lazy future ...
[17:26:36.103] Packages needed by the future expression (n = 0): <none>
[17:26:36.104] Packages needed by future strategies (n = 0): <none>
[17:26:36.104] {
[17:26:36.104]     {
[17:26:36.104]         {
[17:26:36.104]             ...future.startTime <- base::Sys.time()
[17:26:36.104]             {
[17:26:36.104]                 {
[17:26:36.104]                   {
[17:26:36.104]                     {
[17:26:36.104]                       base::local({
[17:26:36.104]                         has_future <- base::requireNamespace("future", 
[17:26:36.104]                           quietly = TRUE)
[17:26:36.104]                         if (has_future) {
[17:26:36.104]                           ns <- base::getNamespace("future")
[17:26:36.104]                           version <- ns[[".package"]][["version"]]
[17:26:36.104]                           if (is.null(version)) 
[17:26:36.104]                             version <- utils::packageVersion("future")
[17:26:36.104]                         }
[17:26:36.104]                         else {
[17:26:36.104]                           version <- NULL
[17:26:36.104]                         }
[17:26:36.104]                         if (!has_future || version < "1.8.0") {
[17:26:36.104]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:36.104]                             "", base::R.version$version.string), 
[17:26:36.104]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:36.104]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:36.104]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:36.104]                               "release", "version")], collapse = " "), 
[17:26:36.104]                             hostname = base::Sys.info()[["nodename"]])
[17:26:36.104]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:36.104]                             info)
[17:26:36.104]                           info <- base::paste(info, collapse = "; ")
[17:26:36.104]                           if (!has_future) {
[17:26:36.104]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:36.104]                               info)
[17:26:36.104]                           }
[17:26:36.104]                           else {
[17:26:36.104]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:36.104]                               info, version)
[17:26:36.104]                           }
[17:26:36.104]                           base::stop(msg)
[17:26:36.104]                         }
[17:26:36.104]                       })
[17:26:36.104]                     }
[17:26:36.104]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:36.104]                     base::options(mc.cores = 1L)
[17:26:36.104]                   }
[17:26:36.104]                   ...future.strategy.old <- future::plan("list")
[17:26:36.104]                   options(future.plan = NULL)
[17:26:36.104]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:36.104]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:36.104]                 }
[17:26:36.104]                 ...future.workdir <- getwd()
[17:26:36.104]             }
[17:26:36.104]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:36.104]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:36.104]         }
[17:26:36.104]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:36.104]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:36.104]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:36.104]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:36.104]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:36.104]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:36.104]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:36.104]             base::names(...future.oldOptions))
[17:26:36.104]     }
[17:26:36.104]     if (FALSE) {
[17:26:36.104]     }
[17:26:36.104]     else {
[17:26:36.104]         if (TRUE) {
[17:26:36.104]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:36.104]                 open = "w")
[17:26:36.104]         }
[17:26:36.104]         else {
[17:26:36.104]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:36.104]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:36.104]         }
[17:26:36.104]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:36.104]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:36.104]             base::sink(type = "output", split = FALSE)
[17:26:36.104]             base::close(...future.stdout)
[17:26:36.104]         }, add = TRUE)
[17:26:36.104]     }
[17:26:36.104]     ...future.frame <- base::sys.nframe()
[17:26:36.104]     ...future.conditions <- base::list()
[17:26:36.104]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:36.104]     if (FALSE) {
[17:26:36.104]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:36.104]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:36.104]     }
[17:26:36.104]     ...future.result <- base::tryCatch({
[17:26:36.104]         base::withCallingHandlers({
[17:26:36.104]             ...future.value <- base::withVisible(base::local({
[17:26:36.104]                 ...future.makeSendCondition <- base::local({
[17:26:36.104]                   sendCondition <- NULL
[17:26:36.104]                   function(frame = 1L) {
[17:26:36.104]                     if (is.function(sendCondition)) 
[17:26:36.104]                       return(sendCondition)
[17:26:36.104]                     ns <- getNamespace("parallel")
[17:26:36.104]                     if (exists("sendData", mode = "function", 
[17:26:36.104]                       envir = ns)) {
[17:26:36.104]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:36.104]                         envir = ns)
[17:26:36.104]                       envir <- sys.frame(frame)
[17:26:36.104]                       master <- NULL
[17:26:36.104]                       while (!identical(envir, .GlobalEnv) && 
[17:26:36.104]                         !identical(envir, emptyenv())) {
[17:26:36.104]                         if (exists("master", mode = "list", envir = envir, 
[17:26:36.104]                           inherits = FALSE)) {
[17:26:36.104]                           master <- get("master", mode = "list", 
[17:26:36.104]                             envir = envir, inherits = FALSE)
[17:26:36.104]                           if (inherits(master, c("SOCKnode", 
[17:26:36.104]                             "SOCK0node"))) {
[17:26:36.104]                             sendCondition <<- function(cond) {
[17:26:36.104]                               data <- list(type = "VALUE", value = cond, 
[17:26:36.104]                                 success = TRUE)
[17:26:36.104]                               parallel_sendData(master, data)
[17:26:36.104]                             }
[17:26:36.104]                             return(sendCondition)
[17:26:36.104]                           }
[17:26:36.104]                         }
[17:26:36.104]                         frame <- frame + 1L
[17:26:36.104]                         envir <- sys.frame(frame)
[17:26:36.104]                       }
[17:26:36.104]                     }
[17:26:36.104]                     sendCondition <<- function(cond) NULL
[17:26:36.104]                   }
[17:26:36.104]                 })
[17:26:36.104]                 withCallingHandlers({
[17:26:36.104]                   {
[17:26:36.104]                     if (ii%%2 == 0) 
[17:26:36.104]                       stop("Woops!")
[17:26:36.104]                     ii
[17:26:36.104]                   }
[17:26:36.104]                 }, immediateCondition = function(cond) {
[17:26:36.104]                   sendCondition <- ...future.makeSendCondition()
[17:26:36.104]                   sendCondition(cond)
[17:26:36.104]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:36.104]                   {
[17:26:36.104]                     inherits <- base::inherits
[17:26:36.104]                     invokeRestart <- base::invokeRestart
[17:26:36.104]                     is.null <- base::is.null
[17:26:36.104]                     muffled <- FALSE
[17:26:36.104]                     if (inherits(cond, "message")) {
[17:26:36.104]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:36.104]                       if (muffled) 
[17:26:36.104]                         invokeRestart("muffleMessage")
[17:26:36.104]                     }
[17:26:36.104]                     else if (inherits(cond, "warning")) {
[17:26:36.104]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:36.104]                       if (muffled) 
[17:26:36.104]                         invokeRestart("muffleWarning")
[17:26:36.104]                     }
[17:26:36.104]                     else if (inherits(cond, "condition")) {
[17:26:36.104]                       if (!is.null(pattern)) {
[17:26:36.104]                         computeRestarts <- base::computeRestarts
[17:26:36.104]                         grepl <- base::grepl
[17:26:36.104]                         restarts <- computeRestarts(cond)
[17:26:36.104]                         for (restart in restarts) {
[17:26:36.104]                           name <- restart$name
[17:26:36.104]                           if (is.null(name)) 
[17:26:36.104]                             next
[17:26:36.104]                           if (!grepl(pattern, name)) 
[17:26:36.104]                             next
[17:26:36.104]                           invokeRestart(restart)
[17:26:36.104]                           muffled <- TRUE
[17:26:36.104]                           break
[17:26:36.104]                         }
[17:26:36.104]                       }
[17:26:36.104]                     }
[17:26:36.104]                     invisible(muffled)
[17:26:36.104]                   }
[17:26:36.104]                   muffleCondition(cond)
[17:26:36.104]                 })
[17:26:36.104]             }))
[17:26:36.104]             future::FutureResult(value = ...future.value$value, 
[17:26:36.104]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:36.104]                   ...future.rng), globalenv = if (FALSE) 
[17:26:36.104]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:36.104]                     ...future.globalenv.names))
[17:26:36.104]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:36.104]         }, condition = base::local({
[17:26:36.104]             c <- base::c
[17:26:36.104]             inherits <- base::inherits
[17:26:36.104]             invokeRestart <- base::invokeRestart
[17:26:36.104]             length <- base::length
[17:26:36.104]             list <- base::list
[17:26:36.104]             seq.int <- base::seq.int
[17:26:36.104]             signalCondition <- base::signalCondition
[17:26:36.104]             sys.calls <- base::sys.calls
[17:26:36.104]             `[[` <- base::`[[`
[17:26:36.104]             `+` <- base::`+`
[17:26:36.104]             `<<-` <- base::`<<-`
[17:26:36.104]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:36.104]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:36.104]                   3L)]
[17:26:36.104]             }
[17:26:36.104]             function(cond) {
[17:26:36.104]                 is_error <- inherits(cond, "error")
[17:26:36.104]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:36.104]                   NULL)
[17:26:36.104]                 if (is_error) {
[17:26:36.104]                   sessionInformation <- function() {
[17:26:36.104]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:36.104]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:36.104]                       search = base::search(), system = base::Sys.info())
[17:26:36.104]                   }
[17:26:36.104]                   ...future.conditions[[length(...future.conditions) + 
[17:26:36.104]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:36.104]                     cond$call), session = sessionInformation(), 
[17:26:36.104]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:36.104]                   signalCondition(cond)
[17:26:36.104]                 }
[17:26:36.104]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:36.104]                 "immediateCondition"))) {
[17:26:36.104]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:36.104]                   ...future.conditions[[length(...future.conditions) + 
[17:26:36.104]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:36.104]                   if (TRUE && !signal) {
[17:26:36.104]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:36.104]                     {
[17:26:36.104]                       inherits <- base::inherits
[17:26:36.104]                       invokeRestart <- base::invokeRestart
[17:26:36.104]                       is.null <- base::is.null
[17:26:36.104]                       muffled <- FALSE
[17:26:36.104]                       if (inherits(cond, "message")) {
[17:26:36.104]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:36.104]                         if (muffled) 
[17:26:36.104]                           invokeRestart("muffleMessage")
[17:26:36.104]                       }
[17:26:36.104]                       else if (inherits(cond, "warning")) {
[17:26:36.104]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:36.104]                         if (muffled) 
[17:26:36.104]                           invokeRestart("muffleWarning")
[17:26:36.104]                       }
[17:26:36.104]                       else if (inherits(cond, "condition")) {
[17:26:36.104]                         if (!is.null(pattern)) {
[17:26:36.104]                           computeRestarts <- base::computeRestarts
[17:26:36.104]                           grepl <- base::grepl
[17:26:36.104]                           restarts <- computeRestarts(cond)
[17:26:36.104]                           for (restart in restarts) {
[17:26:36.104]                             name <- restart$name
[17:26:36.104]                             if (is.null(name)) 
[17:26:36.104]                               next
[17:26:36.104]                             if (!grepl(pattern, name)) 
[17:26:36.104]                               next
[17:26:36.104]                             invokeRestart(restart)
[17:26:36.104]                             muffled <- TRUE
[17:26:36.104]                             break
[17:26:36.104]                           }
[17:26:36.104]                         }
[17:26:36.104]                       }
[17:26:36.104]                       invisible(muffled)
[17:26:36.104]                     }
[17:26:36.104]                     muffleCondition(cond, pattern = "^muffle")
[17:26:36.104]                   }
[17:26:36.104]                 }
[17:26:36.104]                 else {
[17:26:36.104]                   if (TRUE) {
[17:26:36.104]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:36.104]                     {
[17:26:36.104]                       inherits <- base::inherits
[17:26:36.104]                       invokeRestart <- base::invokeRestart
[17:26:36.104]                       is.null <- base::is.null
[17:26:36.104]                       muffled <- FALSE
[17:26:36.104]                       if (inherits(cond, "message")) {
[17:26:36.104]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:36.104]                         if (muffled) 
[17:26:36.104]                           invokeRestart("muffleMessage")
[17:26:36.104]                       }
[17:26:36.104]                       else if (inherits(cond, "warning")) {
[17:26:36.104]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:36.104]                         if (muffled) 
[17:26:36.104]                           invokeRestart("muffleWarning")
[17:26:36.104]                       }
[17:26:36.104]                       else if (inherits(cond, "condition")) {
[17:26:36.104]                         if (!is.null(pattern)) {
[17:26:36.104]                           computeRestarts <- base::computeRestarts
[17:26:36.104]                           grepl <- base::grepl
[17:26:36.104]                           restarts <- computeRestarts(cond)
[17:26:36.104]                           for (restart in restarts) {
[17:26:36.104]                             name <- restart$name
[17:26:36.104]                             if (is.null(name)) 
[17:26:36.104]                               next
[17:26:36.104]                             if (!grepl(pattern, name)) 
[17:26:36.104]                               next
[17:26:36.104]                             invokeRestart(restart)
[17:26:36.104]                             muffled <- TRUE
[17:26:36.104]                             break
[17:26:36.104]                           }
[17:26:36.104]                         }
[17:26:36.104]                       }
[17:26:36.104]                       invisible(muffled)
[17:26:36.104]                     }
[17:26:36.104]                     muffleCondition(cond, pattern = "^muffle")
[17:26:36.104]                   }
[17:26:36.104]                 }
[17:26:36.104]             }
[17:26:36.104]         }))
[17:26:36.104]     }, error = function(ex) {
[17:26:36.104]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:36.104]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:36.104]                 ...future.rng), started = ...future.startTime, 
[17:26:36.104]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:36.104]             version = "1.8"), class = "FutureResult")
[17:26:36.104]     }, finally = {
[17:26:36.104]         if (!identical(...future.workdir, getwd())) 
[17:26:36.104]             setwd(...future.workdir)
[17:26:36.104]         {
[17:26:36.104]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:36.104]                 ...future.oldOptions$nwarnings <- NULL
[17:26:36.104]             }
[17:26:36.104]             base::options(...future.oldOptions)
[17:26:36.104]             if (.Platform$OS.type == "windows") {
[17:26:36.104]                 old_names <- names(...future.oldEnvVars)
[17:26:36.104]                 envs <- base::Sys.getenv()
[17:26:36.104]                 names <- names(envs)
[17:26:36.104]                 common <- intersect(names, old_names)
[17:26:36.104]                 added <- setdiff(names, old_names)
[17:26:36.104]                 removed <- setdiff(old_names, names)
[17:26:36.104]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:36.104]                   envs[common]]
[17:26:36.104]                 NAMES <- toupper(changed)
[17:26:36.104]                 args <- list()
[17:26:36.104]                 for (kk in seq_along(NAMES)) {
[17:26:36.104]                   name <- changed[[kk]]
[17:26:36.104]                   NAME <- NAMES[[kk]]
[17:26:36.104]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:36.104]                     next
[17:26:36.104]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:36.104]                 }
[17:26:36.104]                 NAMES <- toupper(added)
[17:26:36.104]                 for (kk in seq_along(NAMES)) {
[17:26:36.104]                   name <- added[[kk]]
[17:26:36.104]                   NAME <- NAMES[[kk]]
[17:26:36.104]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:36.104]                     next
[17:26:36.104]                   args[[name]] <- ""
[17:26:36.104]                 }
[17:26:36.104]                 NAMES <- toupper(removed)
[17:26:36.104]                 for (kk in seq_along(NAMES)) {
[17:26:36.104]                   name <- removed[[kk]]
[17:26:36.104]                   NAME <- NAMES[[kk]]
[17:26:36.104]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:36.104]                     next
[17:26:36.104]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:36.104]                 }
[17:26:36.104]                 if (length(args) > 0) 
[17:26:36.104]                   base::do.call(base::Sys.setenv, args = args)
[17:26:36.104]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:36.104]             }
[17:26:36.104]             else {
[17:26:36.104]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:36.104]             }
[17:26:36.104]             {
[17:26:36.104]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:36.104]                   0L) {
[17:26:36.104]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:36.104]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:36.104]                   base::options(opts)
[17:26:36.104]                 }
[17:26:36.104]                 {
[17:26:36.104]                   {
[17:26:36.104]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:36.104]                     NULL
[17:26:36.104]                   }
[17:26:36.104]                   options(future.plan = NULL)
[17:26:36.104]                   if (is.na(NA_character_)) 
[17:26:36.104]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:36.104]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:36.104]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:36.104]                     .init = FALSE)
[17:26:36.104]                 }
[17:26:36.104]             }
[17:26:36.104]         }
[17:26:36.104]     })
[17:26:36.104]     if (TRUE) {
[17:26:36.104]         base::sink(type = "output", split = FALSE)
[17:26:36.104]         if (TRUE) {
[17:26:36.104]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:36.104]         }
[17:26:36.104]         else {
[17:26:36.104]             ...future.result["stdout"] <- base::list(NULL)
[17:26:36.104]         }
[17:26:36.104]         base::close(...future.stdout)
[17:26:36.104]         ...future.stdout <- NULL
[17:26:36.104]     }
[17:26:36.104]     ...future.result$conditions <- ...future.conditions
[17:26:36.104]     ...future.result$finished <- base::Sys.time()
[17:26:36.104]     ...future.result
[17:26:36.104] }
[17:26:36.109] Poll #1 (0): usedNodes() = 2, workers = 2
[17:26:36.121] receiveMessageFromWorker() for ClusterFuture ...
[17:26:36.121] - Validating connection of MultisessionFuture
[17:26:36.122] - received message: FutureResult
[17:26:36.122] - Received FutureResult
[17:26:36.122] - Erased future from FutureRegistry
[17:26:36.122] result() for ClusterFuture ...
[17:26:36.122] - result already collected: FutureResult
[17:26:36.122] result() for ClusterFuture ... done
[17:26:36.123] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:36.123] result() for ClusterFuture ...
[17:26:36.123] - result already collected: FutureResult
[17:26:36.123] result() for ClusterFuture ... done
[17:26:36.123] result() for ClusterFuture ...
[17:26:36.123] - result already collected: FutureResult
[17:26:36.124] result() for ClusterFuture ... done
[17:26:36.124] Exporting 1 global objects (56 bytes) to cluster node #1 ...
[17:26:36.124] Exporting 'ii' (56 bytes) to cluster node #1 ...
[17:26:36.125] Exporting 'ii' (56 bytes) to cluster node #1 ... DONE
[17:26:36.125] Exporting 1 global objects (56 bytes) to cluster node #1 ... DONE
[17:26:36.126] MultisessionFuture started
[17:26:36.126] - Launch lazy future ... done
[17:26:36.126] run() for 'MultisessionFuture' ... done
[17:26:36.126] result() for ClusterFuture ...
[17:26:36.126] - result already collected: FutureResult
[17:26:36.127] result() for ClusterFuture ... done
[17:26:36.127] result() for ClusterFuture ...
[17:26:36.127] - result already collected: FutureResult
[17:26:36.127] result() for ClusterFuture ... done
[17:26:36.127] result() for ClusterFuture ...
[17:26:36.127] receiveMessageFromWorker() for ClusterFuture ...
[17:26:36.128] - Validating connection of MultisessionFuture
[17:26:36.131] - received message: FutureResult
[17:26:36.132] - Received FutureResult
[17:26:36.132] - Erased future from FutureRegistry
[17:26:36.132] result() for ClusterFuture ...
[17:26:36.132] - result already collected: FutureResult
[17:26:36.132] result() for ClusterFuture ... done
[17:26:36.132] signalConditions() ...
[17:26:36.132]  - include = 'immediateCondition'
[17:26:36.133]  - exclude = 
[17:26:36.133]  - resignal = FALSE
[17:26:36.133]  - Number of conditions: 1
[17:26:36.133] signalConditions() ... done
[17:26:36.133] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:36.133] result() for ClusterFuture ... done
[17:26:36.134] result() for ClusterFuture ...
[17:26:36.134] - result already collected: FutureResult
[17:26:36.134] result() for ClusterFuture ... done
[17:26:36.134] signalConditions() ...
[17:26:36.134]  - include = 'immediateCondition'
[17:26:36.134]  - exclude = 
[17:26:36.135]  - resignal = FALSE
[17:26:36.135]  - Number of conditions: 1
[17:26:36.135] signalConditions() ... done
[17:26:36.135] Future state: 'finished'
[17:26:36.135] result() for ClusterFuture ...
[17:26:36.135] - result already collected: FutureResult
[17:26:36.136] result() for ClusterFuture ... done
[17:26:36.136] signalConditions() ...
[17:26:36.136]  - include = 'condition'
[17:26:36.136]  - exclude = 'immediateCondition'
[17:26:36.136]  - resignal = TRUE
[17:26:36.136]  - Number of conditions: 1
[17:26:36.137]  - Condition #1: 'simpleError', 'error', 'condition'
[17:26:36.137] signalConditions() ... done
[17:26:36.137] result() for ClusterFuture ...
[17:26:36.137] receiveMessageFromWorker() for ClusterFuture ...
[17:26:36.138] - Validating connection of MultisessionFuture
[17:26:36.140] - received message: FutureResult
[17:26:36.140] - Received FutureResult
[17:26:36.140] - Erased future from FutureRegistry
[17:26:36.141] result() for ClusterFuture ...
[17:26:36.141] - result already collected: FutureResult
[17:26:36.141] result() for ClusterFuture ... done
[17:26:36.141] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:36.141] result() for ClusterFuture ... done
[17:26:36.141] result() for ClusterFuture ...
[17:26:36.141] - result already collected: FutureResult
[17:26:36.142] result() for ClusterFuture ... done
Warning in get(var, envir = x, inherits = FALSE) :
  restarting interrupted promise evaluation
[17:26:36.142] result() for ClusterFuture ...
[17:26:36.142] - result already collected: FutureResult
[17:26:36.142] result() for ClusterFuture ... done
[17:26:36.143] result() for ClusterFuture ...
[17:26:36.143] - result already collected: FutureResult
[17:26:36.143] result() for ClusterFuture ... done
[17:26:36.143] signalConditions() ...
[17:26:36.143]  - include = 'immediateCondition'
[17:26:36.143]  - exclude = 
[17:26:36.144]  - resignal = FALSE
[17:26:36.144]  - Number of conditions: 1
[17:26:36.144] signalConditions() ... done
[17:26:36.144] Future state: 'finished'
[17:26:36.144] result() for ClusterFuture ...
[17:26:36.144] - result already collected: FutureResult
[17:26:36.145] result() for ClusterFuture ... done
[17:26:36.145] signalConditions() ...
[17:26:36.145]  - include = 'condition'
[17:26:36.145]  - exclude = 'immediateCondition'
[17:26:36.145]  - resignal = TRUE
[17:26:36.145]  - Number of conditions: 1
[17:26:36.146]  - Condition #1: 'simpleError', 'error', 'condition'
[17:26:36.146] signalConditions() ... done
Warning in get(var, envir = x, inherits = FALSE) :
  restarting interrupted promise evaluation
[17:26:36.146] result() for ClusterFuture ...
[17:26:36.146] - result already collected: FutureResult
[17:26:36.147] result() for ClusterFuture ... done
[17:26:36.147] result() for ClusterFuture ...
[17:26:36.147] - result already collected: FutureResult
[17:26:36.147] result() for ClusterFuture ... done
[17:26:36.147] signalConditions() ...
[17:26:36.147]  - include = 'immediateCondition'
[17:26:36.147]  - exclude = 
[17:26:36.148]  - resignal = FALSE
[17:26:36.148]  - Number of conditions: 1
[17:26:36.148] signalConditions() ... done
[17:26:36.148] Future state: 'finished'
[17:26:36.148] result() for ClusterFuture ...
[17:26:36.148] - result already collected: FutureResult
[17:26:36.149] result() for ClusterFuture ... done
[17:26:36.149] signalConditions() ...
[17:26:36.149]  - include = 'condition'
[17:26:36.149]  - exclude = 'immediateCondition'
[17:26:36.149]  - resignal = TRUE
[17:26:36.149]  - Number of conditions: 1
[17:26:36.150]  - Condition #1: 'simpleError', 'error', 'condition'
[17:26:36.150] signalConditions() ... done
** Future evaluation with a poor-man's "progress bar"
[17:26:36.150] getGlobalsAndPackages() ...
[17:26:36.150] Searching for globals...
[17:26:36.153] - globals found: [4] '{', 'cat', 'for', ':'
[17:26:36.153] Searching for globals ... DONE
[17:26:36.153] Resolving globals: FALSE
[17:26:36.154] 
[17:26:36.154] 
[17:26:36.154] getGlobalsAndPackages() ... DONE
[17:26:36.154] run() for 'Future' ...
[17:26:36.154] - state: 'created'
[17:26:36.155] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:36.168] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:36.168] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:36.168]   - Field: 'node'
[17:26:36.168]   - Field: 'label'
[17:26:36.169]   - Field: 'local'
[17:26:36.169]   - Field: 'owner'
[17:26:36.169]   - Field: 'envir'
[17:26:36.169]   - Field: 'workers'
[17:26:36.169]   - Field: 'packages'
[17:26:36.169]   - Field: 'gc'
[17:26:36.170]   - Field: 'conditions'
[17:26:36.170]   - Field: 'persistent'
[17:26:36.170]   - Field: 'expr'
[17:26:36.170]   - Field: 'uuid'
[17:26:36.170]   - Field: 'seed'
[17:26:36.170]   - Field: 'version'
[17:26:36.171]   - Field: 'result'
[17:26:36.171]   - Field: 'asynchronous'
[17:26:36.171]   - Field: 'calls'
[17:26:36.171]   - Field: 'globals'
[17:26:36.171]   - Field: 'stdout'
[17:26:36.171]   - Field: 'earlySignal'
[17:26:36.172]   - Field: 'lazy'
[17:26:36.172]   - Field: 'state'
[17:26:36.172] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:36.172] - Launch lazy future ...
[17:26:36.173] Packages needed by the future expression (n = 0): <none>
[17:26:36.173] Packages needed by future strategies (n = 0): <none>
[17:26:36.173] {
[17:26:36.173]     {
[17:26:36.173]         {
[17:26:36.173]             ...future.startTime <- base::Sys.time()
[17:26:36.173]             {
[17:26:36.173]                 {
[17:26:36.173]                   {
[17:26:36.173]                     {
[17:26:36.173]                       base::local({
[17:26:36.173]                         has_future <- base::requireNamespace("future", 
[17:26:36.173]                           quietly = TRUE)
[17:26:36.173]                         if (has_future) {
[17:26:36.173]                           ns <- base::getNamespace("future")
[17:26:36.173]                           version <- ns[[".package"]][["version"]]
[17:26:36.173]                           if (is.null(version)) 
[17:26:36.173]                             version <- utils::packageVersion("future")
[17:26:36.173]                         }
[17:26:36.173]                         else {
[17:26:36.173]                           version <- NULL
[17:26:36.173]                         }
[17:26:36.173]                         if (!has_future || version < "1.8.0") {
[17:26:36.173]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:36.173]                             "", base::R.version$version.string), 
[17:26:36.173]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:36.173]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:36.173]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:36.173]                               "release", "version")], collapse = " "), 
[17:26:36.173]                             hostname = base::Sys.info()[["nodename"]])
[17:26:36.173]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:36.173]                             info)
[17:26:36.173]                           info <- base::paste(info, collapse = "; ")
[17:26:36.173]                           if (!has_future) {
[17:26:36.173]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:36.173]                               info)
[17:26:36.173]                           }
[17:26:36.173]                           else {
[17:26:36.173]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:36.173]                               info, version)
[17:26:36.173]                           }
[17:26:36.173]                           base::stop(msg)
[17:26:36.173]                         }
[17:26:36.173]                       })
[17:26:36.173]                     }
[17:26:36.173]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:36.173]                     base::options(mc.cores = 1L)
[17:26:36.173]                   }
[17:26:36.173]                   ...future.strategy.old <- future::plan("list")
[17:26:36.173]                   options(future.plan = NULL)
[17:26:36.173]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:36.173]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:36.173]                 }
[17:26:36.173]                 ...future.workdir <- getwd()
[17:26:36.173]             }
[17:26:36.173]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:36.173]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:36.173]         }
[17:26:36.173]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:36.173]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:36.173]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:36.173]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:36.173]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:36.173]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:36.173]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:36.173]             base::names(...future.oldOptions))
[17:26:36.173]     }
[17:26:36.173]     if (FALSE) {
[17:26:36.173]     }
[17:26:36.173]     else {
[17:26:36.173]         if (TRUE) {
[17:26:36.173]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:36.173]                 open = "w")
[17:26:36.173]         }
[17:26:36.173]         else {
[17:26:36.173]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:36.173]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:36.173]         }
[17:26:36.173]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:36.173]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:36.173]             base::sink(type = "output", split = FALSE)
[17:26:36.173]             base::close(...future.stdout)
[17:26:36.173]         }, add = TRUE)
[17:26:36.173]     }
[17:26:36.173]     ...future.frame <- base::sys.nframe()
[17:26:36.173]     ...future.conditions <- base::list()
[17:26:36.173]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:36.173]     if (FALSE) {
[17:26:36.173]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:36.173]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:36.173]     }
[17:26:36.173]     ...future.result <- base::tryCatch({
[17:26:36.173]         base::withCallingHandlers({
[17:26:36.173]             ...future.value <- base::withVisible(base::local({
[17:26:36.173]                 ...future.makeSendCondition <- base::local({
[17:26:36.173]                   sendCondition <- NULL
[17:26:36.173]                   function(frame = 1L) {
[17:26:36.173]                     if (is.function(sendCondition)) 
[17:26:36.173]                       return(sendCondition)
[17:26:36.173]                     ns <- getNamespace("parallel")
[17:26:36.173]                     if (exists("sendData", mode = "function", 
[17:26:36.173]                       envir = ns)) {
[17:26:36.173]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:36.173]                         envir = ns)
[17:26:36.173]                       envir <- sys.frame(frame)
[17:26:36.173]                       master <- NULL
[17:26:36.173]                       while (!identical(envir, .GlobalEnv) && 
[17:26:36.173]                         !identical(envir, emptyenv())) {
[17:26:36.173]                         if (exists("master", mode = "list", envir = envir, 
[17:26:36.173]                           inherits = FALSE)) {
[17:26:36.173]                           master <- get("master", mode = "list", 
[17:26:36.173]                             envir = envir, inherits = FALSE)
[17:26:36.173]                           if (inherits(master, c("SOCKnode", 
[17:26:36.173]                             "SOCK0node"))) {
[17:26:36.173]                             sendCondition <<- function(cond) {
[17:26:36.173]                               data <- list(type = "VALUE", value = cond, 
[17:26:36.173]                                 success = TRUE)
[17:26:36.173]                               parallel_sendData(master, data)
[17:26:36.173]                             }
[17:26:36.173]                             return(sendCondition)
[17:26:36.173]                           }
[17:26:36.173]                         }
[17:26:36.173]                         frame <- frame + 1L
[17:26:36.173]                         envir <- sys.frame(frame)
[17:26:36.173]                       }
[17:26:36.173]                     }
[17:26:36.173]                     sendCondition <<- function(cond) NULL
[17:26:36.173]                   }
[17:26:36.173]                 })
[17:26:36.173]                 withCallingHandlers({
[17:26:36.173]                   {
[17:26:36.173]                     cat("Processing: ")
[17:26:36.173]                     for (ii in 1:10) {
[17:26:36.173]                       cat(".")
[17:26:36.173]                     }
[17:26:36.173]                     cat(" [100%]\n")
[17:26:36.173]                     4
[17:26:36.173]                   }
[17:26:36.173]                 }, immediateCondition = function(cond) {
[17:26:36.173]                   sendCondition <- ...future.makeSendCondition()
[17:26:36.173]                   sendCondition(cond)
[17:26:36.173]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:36.173]                   {
[17:26:36.173]                     inherits <- base::inherits
[17:26:36.173]                     invokeRestart <- base::invokeRestart
[17:26:36.173]                     is.null <- base::is.null
[17:26:36.173]                     muffled <- FALSE
[17:26:36.173]                     if (inherits(cond, "message")) {
[17:26:36.173]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:36.173]                       if (muffled) 
[17:26:36.173]                         invokeRestart("muffleMessage")
[17:26:36.173]                     }
[17:26:36.173]                     else if (inherits(cond, "warning")) {
[17:26:36.173]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:36.173]                       if (muffled) 
[17:26:36.173]                         invokeRestart("muffleWarning")
[17:26:36.173]                     }
[17:26:36.173]                     else if (inherits(cond, "condition")) {
[17:26:36.173]                       if (!is.null(pattern)) {
[17:26:36.173]                         computeRestarts <- base::computeRestarts
[17:26:36.173]                         grepl <- base::grepl
[17:26:36.173]                         restarts <- computeRestarts(cond)
[17:26:36.173]                         for (restart in restarts) {
[17:26:36.173]                           name <- restart$name
[17:26:36.173]                           if (is.null(name)) 
[17:26:36.173]                             next
[17:26:36.173]                           if (!grepl(pattern, name)) 
[17:26:36.173]                             next
[17:26:36.173]                           invokeRestart(restart)
[17:26:36.173]                           muffled <- TRUE
[17:26:36.173]                           break
[17:26:36.173]                         }
[17:26:36.173]                       }
[17:26:36.173]                     }
[17:26:36.173]                     invisible(muffled)
[17:26:36.173]                   }
[17:26:36.173]                   muffleCondition(cond)
[17:26:36.173]                 })
[17:26:36.173]             }))
[17:26:36.173]             future::FutureResult(value = ...future.value$value, 
[17:26:36.173]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:36.173]                   ...future.rng), globalenv = if (FALSE) 
[17:26:36.173]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:36.173]                     ...future.globalenv.names))
[17:26:36.173]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:36.173]         }, condition = base::local({
[17:26:36.173]             c <- base::c
[17:26:36.173]             inherits <- base::inherits
[17:26:36.173]             invokeRestart <- base::invokeRestart
[17:26:36.173]             length <- base::length
[17:26:36.173]             list <- base::list
[17:26:36.173]             seq.int <- base::seq.int
[17:26:36.173]             signalCondition <- base::signalCondition
[17:26:36.173]             sys.calls <- base::sys.calls
[17:26:36.173]             `[[` <- base::`[[`
[17:26:36.173]             `+` <- base::`+`
[17:26:36.173]             `<<-` <- base::`<<-`
[17:26:36.173]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:36.173]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:36.173]                   3L)]
[17:26:36.173]             }
[17:26:36.173]             function(cond) {
[17:26:36.173]                 is_error <- inherits(cond, "error")
[17:26:36.173]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:36.173]                   NULL)
[17:26:36.173]                 if (is_error) {
[17:26:36.173]                   sessionInformation <- function() {
[17:26:36.173]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:36.173]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:36.173]                       search = base::search(), system = base::Sys.info())
[17:26:36.173]                   }
[17:26:36.173]                   ...future.conditions[[length(...future.conditions) + 
[17:26:36.173]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:36.173]                     cond$call), session = sessionInformation(), 
[17:26:36.173]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:36.173]                   signalCondition(cond)
[17:26:36.173]                 }
[17:26:36.173]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:36.173]                 "immediateCondition"))) {
[17:26:36.173]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:36.173]                   ...future.conditions[[length(...future.conditions) + 
[17:26:36.173]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:36.173]                   if (TRUE && !signal) {
[17:26:36.173]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:36.173]                     {
[17:26:36.173]                       inherits <- base::inherits
[17:26:36.173]                       invokeRestart <- base::invokeRestart
[17:26:36.173]                       is.null <- base::is.null
[17:26:36.173]                       muffled <- FALSE
[17:26:36.173]                       if (inherits(cond, "message")) {
[17:26:36.173]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:36.173]                         if (muffled) 
[17:26:36.173]                           invokeRestart("muffleMessage")
[17:26:36.173]                       }
[17:26:36.173]                       else if (inherits(cond, "warning")) {
[17:26:36.173]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:36.173]                         if (muffled) 
[17:26:36.173]                           invokeRestart("muffleWarning")
[17:26:36.173]                       }
[17:26:36.173]                       else if (inherits(cond, "condition")) {
[17:26:36.173]                         if (!is.null(pattern)) {
[17:26:36.173]                           computeRestarts <- base::computeRestarts
[17:26:36.173]                           grepl <- base::grepl
[17:26:36.173]                           restarts <- computeRestarts(cond)
[17:26:36.173]                           for (restart in restarts) {
[17:26:36.173]                             name <- restart$name
[17:26:36.173]                             if (is.null(name)) 
[17:26:36.173]                               next
[17:26:36.173]                             if (!grepl(pattern, name)) 
[17:26:36.173]                               next
[17:26:36.173]                             invokeRestart(restart)
[17:26:36.173]                             muffled <- TRUE
[17:26:36.173]                             break
[17:26:36.173]                           }
[17:26:36.173]                         }
[17:26:36.173]                       }
[17:26:36.173]                       invisible(muffled)
[17:26:36.173]                     }
[17:26:36.173]                     muffleCondition(cond, pattern = "^muffle")
[17:26:36.173]                   }
[17:26:36.173]                 }
[17:26:36.173]                 else {
[17:26:36.173]                   if (TRUE) {
[17:26:36.173]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:36.173]                     {
[17:26:36.173]                       inherits <- base::inherits
[17:26:36.173]                       invokeRestart <- base::invokeRestart
[17:26:36.173]                       is.null <- base::is.null
[17:26:36.173]                       muffled <- FALSE
[17:26:36.173]                       if (inherits(cond, "message")) {
[17:26:36.173]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:36.173]                         if (muffled) 
[17:26:36.173]                           invokeRestart("muffleMessage")
[17:26:36.173]                       }
[17:26:36.173]                       else if (inherits(cond, "warning")) {
[17:26:36.173]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:36.173]                         if (muffled) 
[17:26:36.173]                           invokeRestart("muffleWarning")
[17:26:36.173]                       }
[17:26:36.173]                       else if (inherits(cond, "condition")) {
[17:26:36.173]                         if (!is.null(pattern)) {
[17:26:36.173]                           computeRestarts <- base::computeRestarts
[17:26:36.173]                           grepl <- base::grepl
[17:26:36.173]                           restarts <- computeRestarts(cond)
[17:26:36.173]                           for (restart in restarts) {
[17:26:36.173]                             name <- restart$name
[17:26:36.173]                             if (is.null(name)) 
[17:26:36.173]                               next
[17:26:36.173]                             if (!grepl(pattern, name)) 
[17:26:36.173]                               next
[17:26:36.173]                             invokeRestart(restart)
[17:26:36.173]                             muffled <- TRUE
[17:26:36.173]                             break
[17:26:36.173]                           }
[17:26:36.173]                         }
[17:26:36.173]                       }
[17:26:36.173]                       invisible(muffled)
[17:26:36.173]                     }
[17:26:36.173]                     muffleCondition(cond, pattern = "^muffle")
[17:26:36.173]                   }
[17:26:36.173]                 }
[17:26:36.173]             }
[17:26:36.173]         }))
[17:26:36.173]     }, error = function(ex) {
[17:26:36.173]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:36.173]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:36.173]                 ...future.rng), started = ...future.startTime, 
[17:26:36.173]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:36.173]             version = "1.8"), class = "FutureResult")
[17:26:36.173]     }, finally = {
[17:26:36.173]         if (!identical(...future.workdir, getwd())) 
[17:26:36.173]             setwd(...future.workdir)
[17:26:36.173]         {
[17:26:36.173]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:36.173]                 ...future.oldOptions$nwarnings <- NULL
[17:26:36.173]             }
[17:26:36.173]             base::options(...future.oldOptions)
[17:26:36.173]             if (.Platform$OS.type == "windows") {
[17:26:36.173]                 old_names <- names(...future.oldEnvVars)
[17:26:36.173]                 envs <- base::Sys.getenv()
[17:26:36.173]                 names <- names(envs)
[17:26:36.173]                 common <- intersect(names, old_names)
[17:26:36.173]                 added <- setdiff(names, old_names)
[17:26:36.173]                 removed <- setdiff(old_names, names)
[17:26:36.173]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:36.173]                   envs[common]]
[17:26:36.173]                 NAMES <- toupper(changed)
[17:26:36.173]                 args <- list()
[17:26:36.173]                 for (kk in seq_along(NAMES)) {
[17:26:36.173]                   name <- changed[[kk]]
[17:26:36.173]                   NAME <- NAMES[[kk]]
[17:26:36.173]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:36.173]                     next
[17:26:36.173]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:36.173]                 }
[17:26:36.173]                 NAMES <- toupper(added)
[17:26:36.173]                 for (kk in seq_along(NAMES)) {
[17:26:36.173]                   name <- added[[kk]]
[17:26:36.173]                   NAME <- NAMES[[kk]]
[17:26:36.173]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:36.173]                     next
[17:26:36.173]                   args[[name]] <- ""
[17:26:36.173]                 }
[17:26:36.173]                 NAMES <- toupper(removed)
[17:26:36.173]                 for (kk in seq_along(NAMES)) {
[17:26:36.173]                   name <- removed[[kk]]
[17:26:36.173]                   NAME <- NAMES[[kk]]
[17:26:36.173]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:36.173]                     next
[17:26:36.173]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:36.173]                 }
[17:26:36.173]                 if (length(args) > 0) 
[17:26:36.173]                   base::do.call(base::Sys.setenv, args = args)
[17:26:36.173]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:36.173]             }
[17:26:36.173]             else {
[17:26:36.173]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:36.173]             }
[17:26:36.173]             {
[17:26:36.173]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:36.173]                   0L) {
[17:26:36.173]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:36.173]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:36.173]                   base::options(opts)
[17:26:36.173]                 }
[17:26:36.173]                 {
[17:26:36.173]                   {
[17:26:36.173]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:36.173]                     NULL
[17:26:36.173]                   }
[17:26:36.173]                   options(future.plan = NULL)
[17:26:36.173]                   if (is.na(NA_character_)) 
[17:26:36.173]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:36.173]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:36.173]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:36.173]                     .init = FALSE)
[17:26:36.173]                 }
[17:26:36.173]             }
[17:26:36.173]         }
[17:26:36.173]     })
[17:26:36.173]     if (TRUE) {
[17:26:36.173]         base::sink(type = "output", split = FALSE)
[17:26:36.173]         if (TRUE) {
[17:26:36.173]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:36.173]         }
[17:26:36.173]         else {
[17:26:36.173]             ...future.result["stdout"] <- base::list(NULL)
[17:26:36.173]         }
[17:26:36.173]         base::close(...future.stdout)
[17:26:36.173]         ...future.stdout <- NULL
[17:26:36.173]     }
[17:26:36.173]     ...future.result$conditions <- ...future.conditions
[17:26:36.173]     ...future.result$finished <- base::Sys.time()
[17:26:36.173]     ...future.result
[17:26:36.173] }
[17:26:36.179] MultisessionFuture started
[17:26:36.179] - Launch lazy future ... done
[17:26:36.179] run() for 'MultisessionFuture' ... done
** Collecting results
v1 = 1
v2 = 2
Warning in sprintf(...) : restarting interrupted promise evaluation
[17:26:36.179] result() for ClusterFuture ...
[17:26:36.180] - result already collected: FutureResult
[17:26:36.180] result() for ClusterFuture ... done
[17:26:36.180] result() for ClusterFuture ...
[17:26:36.180] - result already collected: FutureResult
[17:26:36.180] result() for ClusterFuture ... done
[17:26:36.180] signalConditions() ...
[17:26:36.181]  - include = 'immediateCondition'
[17:26:36.181]  - exclude = 
[17:26:36.181]  - resignal = FALSE
[17:26:36.181]  - Number of conditions: 1
[17:26:36.181] signalConditions() ... done
[17:26:36.181] Future state: 'finished'
[17:26:36.182] result() for ClusterFuture ...
[17:26:36.182] - result already collected: FutureResult
[17:26:36.182] result() for ClusterFuture ... done
[17:26:36.182] signalConditions() ...
[17:26:36.182]  - include = 'condition'
[17:26:36.182]  - exclude = 'immediateCondition'
[17:26:36.183]  - resignal = TRUE
[17:26:36.183]  - Number of conditions: 1
[17:26:36.183]  - Condition #1: 'simpleError', 'error', 'condition'
[17:26:36.183] signalConditions() ... done
v3: <simpleError> (as expect)
[17:26:36.183] result() for ClusterFuture ...
[17:26:36.184] receiveMessageFromWorker() for ClusterFuture ...
[17:26:36.184] - Validating connection of MultisessionFuture
[17:26:36.194] - received message: FutureResult
[17:26:36.195] - Received FutureResult
[17:26:36.195] - Erased future from FutureRegistry
[17:26:36.195] result() for ClusterFuture ...
[17:26:36.195] - result already collected: FutureResult
[17:26:36.195] result() for ClusterFuture ... done
[17:26:36.195] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:36.196] result() for ClusterFuture ... done
[17:26:36.196] result() for ClusterFuture ...
[17:26:36.196] - result already collected: FutureResult
[17:26:36.196] result() for ClusterFuture ... done
Processing: .......... [100%]
v4 = 4
** Left-to-right and right-to-left future assignments
[17:26:36.196] getGlobalsAndPackages() ...
[17:26:36.197] Searching for globals...
[17:26:36.197] 
[17:26:36.197] Searching for globals ... DONE
[17:26:36.198] - globals: [0] <none>
[17:26:36.198] getGlobalsAndPackages() ... DONE
[17:26:36.198] run() for 'Future' ...
[17:26:36.198] - state: 'created'
[17:26:36.198] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:36.213] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:36.213] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:36.213]   - Field: 'node'
[17:26:36.213]   - Field: 'label'
[17:26:36.213]   - Field: 'local'
[17:26:36.214]   - Field: 'owner'
[17:26:36.214]   - Field: 'envir'
[17:26:36.214]   - Field: 'workers'
[17:26:36.214]   - Field: 'packages'
[17:26:36.214]   - Field: 'gc'
[17:26:36.215]   - Field: 'conditions'
[17:26:36.215]   - Field: 'persistent'
[17:26:36.215]   - Field: 'expr'
[17:26:36.215]   - Field: 'uuid'
[17:26:36.215]   - Field: 'seed'
[17:26:36.216]   - Field: 'version'
[17:26:36.216]   - Field: 'result'
[17:26:36.216]   - Field: 'asynchronous'
[17:26:36.216]   - Field: 'calls'
[17:26:36.216]   - Field: 'globals'
[17:26:36.217]   - Field: 'stdout'
[17:26:36.217]   - Field: 'earlySignal'
[17:26:36.217]   - Field: 'lazy'
[17:26:36.217]   - Field: 'state'
[17:26:36.217] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:36.217] - Launch lazy future ...
[17:26:36.218] Packages needed by the future expression (n = 0): <none>
[17:26:36.218] Packages needed by future strategies (n = 0): <none>
[17:26:36.219] {
[17:26:36.219]     {
[17:26:36.219]         {
[17:26:36.219]             ...future.startTime <- base::Sys.time()
[17:26:36.219]             {
[17:26:36.219]                 {
[17:26:36.219]                   {
[17:26:36.219]                     {
[17:26:36.219]                       base::local({
[17:26:36.219]                         has_future <- base::requireNamespace("future", 
[17:26:36.219]                           quietly = TRUE)
[17:26:36.219]                         if (has_future) {
[17:26:36.219]                           ns <- base::getNamespace("future")
[17:26:36.219]                           version <- ns[[".package"]][["version"]]
[17:26:36.219]                           if (is.null(version)) 
[17:26:36.219]                             version <- utils::packageVersion("future")
[17:26:36.219]                         }
[17:26:36.219]                         else {
[17:26:36.219]                           version <- NULL
[17:26:36.219]                         }
[17:26:36.219]                         if (!has_future || version < "1.8.0") {
[17:26:36.219]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:36.219]                             "", base::R.version$version.string), 
[17:26:36.219]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:36.219]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:36.219]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:36.219]                               "release", "version")], collapse = " "), 
[17:26:36.219]                             hostname = base::Sys.info()[["nodename"]])
[17:26:36.219]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:36.219]                             info)
[17:26:36.219]                           info <- base::paste(info, collapse = "; ")
[17:26:36.219]                           if (!has_future) {
[17:26:36.219]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:36.219]                               info)
[17:26:36.219]                           }
[17:26:36.219]                           else {
[17:26:36.219]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:36.219]                               info, version)
[17:26:36.219]                           }
[17:26:36.219]                           base::stop(msg)
[17:26:36.219]                         }
[17:26:36.219]                       })
[17:26:36.219]                     }
[17:26:36.219]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:36.219]                     base::options(mc.cores = 1L)
[17:26:36.219]                   }
[17:26:36.219]                   ...future.strategy.old <- future::plan("list")
[17:26:36.219]                   options(future.plan = NULL)
[17:26:36.219]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:36.219]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:36.219]                 }
[17:26:36.219]                 ...future.workdir <- getwd()
[17:26:36.219]             }
[17:26:36.219]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:36.219]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:36.219]         }
[17:26:36.219]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:36.219]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:36.219]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:36.219]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:36.219]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:36.219]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:36.219]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:36.219]             base::names(...future.oldOptions))
[17:26:36.219]     }
[17:26:36.219]     if (FALSE) {
[17:26:36.219]     }
[17:26:36.219]     else {
[17:26:36.219]         if (TRUE) {
[17:26:36.219]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:36.219]                 open = "w")
[17:26:36.219]         }
[17:26:36.219]         else {
[17:26:36.219]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:36.219]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:36.219]         }
[17:26:36.219]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:36.219]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:36.219]             base::sink(type = "output", split = FALSE)
[17:26:36.219]             base::close(...future.stdout)
[17:26:36.219]         }, add = TRUE)
[17:26:36.219]     }
[17:26:36.219]     ...future.frame <- base::sys.nframe()
[17:26:36.219]     ...future.conditions <- base::list()
[17:26:36.219]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:36.219]     if (FALSE) {
[17:26:36.219]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:36.219]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:36.219]     }
[17:26:36.219]     ...future.result <- base::tryCatch({
[17:26:36.219]         base::withCallingHandlers({
[17:26:36.219]             ...future.value <- base::withVisible(base::local({
[17:26:36.219]                 ...future.makeSendCondition <- base::local({
[17:26:36.219]                   sendCondition <- NULL
[17:26:36.219]                   function(frame = 1L) {
[17:26:36.219]                     if (is.function(sendCondition)) 
[17:26:36.219]                       return(sendCondition)
[17:26:36.219]                     ns <- getNamespace("parallel")
[17:26:36.219]                     if (exists("sendData", mode = "function", 
[17:26:36.219]                       envir = ns)) {
[17:26:36.219]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:36.219]                         envir = ns)
[17:26:36.219]                       envir <- sys.frame(frame)
[17:26:36.219]                       master <- NULL
[17:26:36.219]                       while (!identical(envir, .GlobalEnv) && 
[17:26:36.219]                         !identical(envir, emptyenv())) {
[17:26:36.219]                         if (exists("master", mode = "list", envir = envir, 
[17:26:36.219]                           inherits = FALSE)) {
[17:26:36.219]                           master <- get("master", mode = "list", 
[17:26:36.219]                             envir = envir, inherits = FALSE)
[17:26:36.219]                           if (inherits(master, c("SOCKnode", 
[17:26:36.219]                             "SOCK0node"))) {
[17:26:36.219]                             sendCondition <<- function(cond) {
[17:26:36.219]                               data <- list(type = "VALUE", value = cond, 
[17:26:36.219]                                 success = TRUE)
[17:26:36.219]                               parallel_sendData(master, data)
[17:26:36.219]                             }
[17:26:36.219]                             return(sendCondition)
[17:26:36.219]                           }
[17:26:36.219]                         }
[17:26:36.219]                         frame <- frame + 1L
[17:26:36.219]                         envir <- sys.frame(frame)
[17:26:36.219]                       }
[17:26:36.219]                     }
[17:26:36.219]                     sendCondition <<- function(cond) NULL
[17:26:36.219]                   }
[17:26:36.219]                 })
[17:26:36.219]                 withCallingHandlers({
[17:26:36.219]                   1
[17:26:36.219]                 }, immediateCondition = function(cond) {
[17:26:36.219]                   sendCondition <- ...future.makeSendCondition()
[17:26:36.219]                   sendCondition(cond)
[17:26:36.219]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:36.219]                   {
[17:26:36.219]                     inherits <- base::inherits
[17:26:36.219]                     invokeRestart <- base::invokeRestart
[17:26:36.219]                     is.null <- base::is.null
[17:26:36.219]                     muffled <- FALSE
[17:26:36.219]                     if (inherits(cond, "message")) {
[17:26:36.219]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:36.219]                       if (muffled) 
[17:26:36.219]                         invokeRestart("muffleMessage")
[17:26:36.219]                     }
[17:26:36.219]                     else if (inherits(cond, "warning")) {
[17:26:36.219]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:36.219]                       if (muffled) 
[17:26:36.219]                         invokeRestart("muffleWarning")
[17:26:36.219]                     }
[17:26:36.219]                     else if (inherits(cond, "condition")) {
[17:26:36.219]                       if (!is.null(pattern)) {
[17:26:36.219]                         computeRestarts <- base::computeRestarts
[17:26:36.219]                         grepl <- base::grepl
[17:26:36.219]                         restarts <- computeRestarts(cond)
[17:26:36.219]                         for (restart in restarts) {
[17:26:36.219]                           name <- restart$name
[17:26:36.219]                           if (is.null(name)) 
[17:26:36.219]                             next
[17:26:36.219]                           if (!grepl(pattern, name)) 
[17:26:36.219]                             next
[17:26:36.219]                           invokeRestart(restart)
[17:26:36.219]                           muffled <- TRUE
[17:26:36.219]                           break
[17:26:36.219]                         }
[17:26:36.219]                       }
[17:26:36.219]                     }
[17:26:36.219]                     invisible(muffled)
[17:26:36.219]                   }
[17:26:36.219]                   muffleCondition(cond)
[17:26:36.219]                 })
[17:26:36.219]             }))
[17:26:36.219]             future::FutureResult(value = ...future.value$value, 
[17:26:36.219]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:36.219]                   ...future.rng), globalenv = if (FALSE) 
[17:26:36.219]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:36.219]                     ...future.globalenv.names))
[17:26:36.219]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:36.219]         }, condition = base::local({
[17:26:36.219]             c <- base::c
[17:26:36.219]             inherits <- base::inherits
[17:26:36.219]             invokeRestart <- base::invokeRestart
[17:26:36.219]             length <- base::length
[17:26:36.219]             list <- base::list
[17:26:36.219]             seq.int <- base::seq.int
[17:26:36.219]             signalCondition <- base::signalCondition
[17:26:36.219]             sys.calls <- base::sys.calls
[17:26:36.219]             `[[` <- base::`[[`
[17:26:36.219]             `+` <- base::`+`
[17:26:36.219]             `<<-` <- base::`<<-`
[17:26:36.219]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:36.219]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:36.219]                   3L)]
[17:26:36.219]             }
[17:26:36.219]             function(cond) {
[17:26:36.219]                 is_error <- inherits(cond, "error")
[17:26:36.219]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:36.219]                   NULL)
[17:26:36.219]                 if (is_error) {
[17:26:36.219]                   sessionInformation <- function() {
[17:26:36.219]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:36.219]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:36.219]                       search = base::search(), system = base::Sys.info())
[17:26:36.219]                   }
[17:26:36.219]                   ...future.conditions[[length(...future.conditions) + 
[17:26:36.219]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:36.219]                     cond$call), session = sessionInformation(), 
[17:26:36.219]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:36.219]                   signalCondition(cond)
[17:26:36.219]                 }
[17:26:36.219]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:36.219]                 "immediateCondition"))) {
[17:26:36.219]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:36.219]                   ...future.conditions[[length(...future.conditions) + 
[17:26:36.219]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:36.219]                   if (TRUE && !signal) {
[17:26:36.219]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:36.219]                     {
[17:26:36.219]                       inherits <- base::inherits
[17:26:36.219]                       invokeRestart <- base::invokeRestart
[17:26:36.219]                       is.null <- base::is.null
[17:26:36.219]                       muffled <- FALSE
[17:26:36.219]                       if (inherits(cond, "message")) {
[17:26:36.219]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:36.219]                         if (muffled) 
[17:26:36.219]                           invokeRestart("muffleMessage")
[17:26:36.219]                       }
[17:26:36.219]                       else if (inherits(cond, "warning")) {
[17:26:36.219]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:36.219]                         if (muffled) 
[17:26:36.219]                           invokeRestart("muffleWarning")
[17:26:36.219]                       }
[17:26:36.219]                       else if (inherits(cond, "condition")) {
[17:26:36.219]                         if (!is.null(pattern)) {
[17:26:36.219]                           computeRestarts <- base::computeRestarts
[17:26:36.219]                           grepl <- base::grepl
[17:26:36.219]                           restarts <- computeRestarts(cond)
[17:26:36.219]                           for (restart in restarts) {
[17:26:36.219]                             name <- restart$name
[17:26:36.219]                             if (is.null(name)) 
[17:26:36.219]                               next
[17:26:36.219]                             if (!grepl(pattern, name)) 
[17:26:36.219]                               next
[17:26:36.219]                             invokeRestart(restart)
[17:26:36.219]                             muffled <- TRUE
[17:26:36.219]                             break
[17:26:36.219]                           }
[17:26:36.219]                         }
[17:26:36.219]                       }
[17:26:36.219]                       invisible(muffled)
[17:26:36.219]                     }
[17:26:36.219]                     muffleCondition(cond, pattern = "^muffle")
[17:26:36.219]                   }
[17:26:36.219]                 }
[17:26:36.219]                 else {
[17:26:36.219]                   if (TRUE) {
[17:26:36.219]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:36.219]                     {
[17:26:36.219]                       inherits <- base::inherits
[17:26:36.219]                       invokeRestart <- base::invokeRestart
[17:26:36.219]                       is.null <- base::is.null
[17:26:36.219]                       muffled <- FALSE
[17:26:36.219]                       if (inherits(cond, "message")) {
[17:26:36.219]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:36.219]                         if (muffled) 
[17:26:36.219]                           invokeRestart("muffleMessage")
[17:26:36.219]                       }
[17:26:36.219]                       else if (inherits(cond, "warning")) {
[17:26:36.219]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:36.219]                         if (muffled) 
[17:26:36.219]                           invokeRestart("muffleWarning")
[17:26:36.219]                       }
[17:26:36.219]                       else if (inherits(cond, "condition")) {
[17:26:36.219]                         if (!is.null(pattern)) {
[17:26:36.219]                           computeRestarts <- base::computeRestarts
[17:26:36.219]                           grepl <- base::grepl
[17:26:36.219]                           restarts <- computeRestarts(cond)
[17:26:36.219]                           for (restart in restarts) {
[17:26:36.219]                             name <- restart$name
[17:26:36.219]                             if (is.null(name)) 
[17:26:36.219]                               next
[17:26:36.219]                             if (!grepl(pattern, name)) 
[17:26:36.219]                               next
[17:26:36.219]                             invokeRestart(restart)
[17:26:36.219]                             muffled <- TRUE
[17:26:36.219]                             break
[17:26:36.219]                           }
[17:26:36.219]                         }
[17:26:36.219]                       }
[17:26:36.219]                       invisible(muffled)
[17:26:36.219]                     }
[17:26:36.219]                     muffleCondition(cond, pattern = "^muffle")
[17:26:36.219]                   }
[17:26:36.219]                 }
[17:26:36.219]             }
[17:26:36.219]         }))
[17:26:36.219]     }, error = function(ex) {
[17:26:36.219]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:36.219]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:36.219]                 ...future.rng), started = ...future.startTime, 
[17:26:36.219]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:36.219]             version = "1.8"), class = "FutureResult")
[17:26:36.219]     }, finally = {
[17:26:36.219]         if (!identical(...future.workdir, getwd())) 
[17:26:36.219]             setwd(...future.workdir)
[17:26:36.219]         {
[17:26:36.219]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:36.219]                 ...future.oldOptions$nwarnings <- NULL
[17:26:36.219]             }
[17:26:36.219]             base::options(...future.oldOptions)
[17:26:36.219]             if (.Platform$OS.type == "windows") {
[17:26:36.219]                 old_names <- names(...future.oldEnvVars)
[17:26:36.219]                 envs <- base::Sys.getenv()
[17:26:36.219]                 names <- names(envs)
[17:26:36.219]                 common <- intersect(names, old_names)
[17:26:36.219]                 added <- setdiff(names, old_names)
[17:26:36.219]                 removed <- setdiff(old_names, names)
[17:26:36.219]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:36.219]                   envs[common]]
[17:26:36.219]                 NAMES <- toupper(changed)
[17:26:36.219]                 args <- list()
[17:26:36.219]                 for (kk in seq_along(NAMES)) {
[17:26:36.219]                   name <- changed[[kk]]
[17:26:36.219]                   NAME <- NAMES[[kk]]
[17:26:36.219]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:36.219]                     next
[17:26:36.219]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:36.219]                 }
[17:26:36.219]                 NAMES <- toupper(added)
[17:26:36.219]                 for (kk in seq_along(NAMES)) {
[17:26:36.219]                   name <- added[[kk]]
[17:26:36.219]                   NAME <- NAMES[[kk]]
[17:26:36.219]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:36.219]                     next
[17:26:36.219]                   args[[name]] <- ""
[17:26:36.219]                 }
[17:26:36.219]                 NAMES <- toupper(removed)
[17:26:36.219]                 for (kk in seq_along(NAMES)) {
[17:26:36.219]                   name <- removed[[kk]]
[17:26:36.219]                   NAME <- NAMES[[kk]]
[17:26:36.219]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:36.219]                     next
[17:26:36.219]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:36.219]                 }
[17:26:36.219]                 if (length(args) > 0) 
[17:26:36.219]                   base::do.call(base::Sys.setenv, args = args)
[17:26:36.219]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:36.219]             }
[17:26:36.219]             else {
[17:26:36.219]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:36.219]             }
[17:26:36.219]             {
[17:26:36.219]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:36.219]                   0L) {
[17:26:36.219]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:36.219]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:36.219]                   base::options(opts)
[17:26:36.219]                 }
[17:26:36.219]                 {
[17:26:36.219]                   {
[17:26:36.219]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:36.219]                     NULL
[17:26:36.219]                   }
[17:26:36.219]                   options(future.plan = NULL)
[17:26:36.219]                   if (is.na(NA_character_)) 
[17:26:36.219]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:36.219]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:36.219]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:36.219]                     .init = FALSE)
[17:26:36.219]                 }
[17:26:36.219]             }
[17:26:36.219]         }
[17:26:36.219]     })
[17:26:36.219]     if (TRUE) {
[17:26:36.219]         base::sink(type = "output", split = FALSE)
[17:26:36.219]         if (TRUE) {
[17:26:36.219]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:36.219]         }
[17:26:36.219]         else {
[17:26:36.219]             ...future.result["stdout"] <- base::list(NULL)
[17:26:36.219]         }
[17:26:36.219]         base::close(...future.stdout)
[17:26:36.219]         ...future.stdout <- NULL
[17:26:36.219]     }
[17:26:36.219]     ...future.result$conditions <- ...future.conditions
[17:26:36.219]     ...future.result$finished <- base::Sys.time()
[17:26:36.219]     ...future.result
[17:26:36.219] }
[17:26:36.224] MultisessionFuture started
[17:26:36.224] - Launch lazy future ... done
[17:26:36.224] run() for 'MultisessionFuture' ... done
[17:26:36.225] result() for ClusterFuture ...
[17:26:36.225] receiveMessageFromWorker() for ClusterFuture ...
[17:26:36.225] - Validating connection of MultisessionFuture
[17:26:36.238] - received message: FutureResult
[17:26:36.238] - Received FutureResult
[17:26:36.238] - Erased future from FutureRegistry
[17:26:36.240] result() for ClusterFuture ...
[17:26:36.240] - result already collected: FutureResult
[17:26:36.240] result() for ClusterFuture ... done
[17:26:36.241] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:36.241] result() for ClusterFuture ... done
[17:26:36.241] result() for ClusterFuture ...
[17:26:36.241] - result already collected: FutureResult
[17:26:36.241] result() for ClusterFuture ... done
c = 1
[17:26:36.241] getGlobalsAndPackages() ...
[17:26:36.242] Searching for globals...
[17:26:36.242] 
[17:26:36.242] Searching for globals ... DONE
[17:26:36.242] - globals: [0] <none>
[17:26:36.243] getGlobalsAndPackages() ... DONE
[17:26:36.243] run() for 'Future' ...
[17:26:36.243] - state: 'created'
[17:26:36.243] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:36.257] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:36.257] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:36.257]   - Field: 'node'
[17:26:36.257]   - Field: 'label'
[17:26:36.257]   - Field: 'local'
[17:26:36.258]   - Field: 'owner'
[17:26:36.258]   - Field: 'envir'
[17:26:36.258]   - Field: 'workers'
[17:26:36.258]   - Field: 'packages'
[17:26:36.258]   - Field: 'gc'
[17:26:36.258]   - Field: 'conditions'
[17:26:36.259]   - Field: 'persistent'
[17:26:36.259]   - Field: 'expr'
[17:26:36.259]   - Field: 'uuid'
[17:26:36.259]   - Field: 'seed'
[17:26:36.259]   - Field: 'version'
[17:26:36.259]   - Field: 'result'
[17:26:36.260]   - Field: 'asynchronous'
[17:26:36.260]   - Field: 'calls'
[17:26:36.260]   - Field: 'globals'
[17:26:36.260]   - Field: 'stdout'
[17:26:36.260]   - Field: 'earlySignal'
[17:26:36.260]   - Field: 'lazy'
[17:26:36.261]   - Field: 'state'
[17:26:36.261] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:36.261] - Launch lazy future ...
[17:26:36.261] Packages needed by the future expression (n = 0): <none>
[17:26:36.261] Packages needed by future strategies (n = 0): <none>
[17:26:36.262] {
[17:26:36.262]     {
[17:26:36.262]         {
[17:26:36.262]             ...future.startTime <- base::Sys.time()
[17:26:36.262]             {
[17:26:36.262]                 {
[17:26:36.262]                   {
[17:26:36.262]                     {
[17:26:36.262]                       base::local({
[17:26:36.262]                         has_future <- base::requireNamespace("future", 
[17:26:36.262]                           quietly = TRUE)
[17:26:36.262]                         if (has_future) {
[17:26:36.262]                           ns <- base::getNamespace("future")
[17:26:36.262]                           version <- ns[[".package"]][["version"]]
[17:26:36.262]                           if (is.null(version)) 
[17:26:36.262]                             version <- utils::packageVersion("future")
[17:26:36.262]                         }
[17:26:36.262]                         else {
[17:26:36.262]                           version <- NULL
[17:26:36.262]                         }
[17:26:36.262]                         if (!has_future || version < "1.8.0") {
[17:26:36.262]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:36.262]                             "", base::R.version$version.string), 
[17:26:36.262]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:36.262]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:36.262]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:36.262]                               "release", "version")], collapse = " "), 
[17:26:36.262]                             hostname = base::Sys.info()[["nodename"]])
[17:26:36.262]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:36.262]                             info)
[17:26:36.262]                           info <- base::paste(info, collapse = "; ")
[17:26:36.262]                           if (!has_future) {
[17:26:36.262]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:36.262]                               info)
[17:26:36.262]                           }
[17:26:36.262]                           else {
[17:26:36.262]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:36.262]                               info, version)
[17:26:36.262]                           }
[17:26:36.262]                           base::stop(msg)
[17:26:36.262]                         }
[17:26:36.262]                       })
[17:26:36.262]                     }
[17:26:36.262]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:36.262]                     base::options(mc.cores = 1L)
[17:26:36.262]                   }
[17:26:36.262]                   ...future.strategy.old <- future::plan("list")
[17:26:36.262]                   options(future.plan = NULL)
[17:26:36.262]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:36.262]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:36.262]                 }
[17:26:36.262]                 ...future.workdir <- getwd()
[17:26:36.262]             }
[17:26:36.262]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:36.262]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:36.262]         }
[17:26:36.262]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:36.262]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:36.262]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:36.262]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:36.262]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:36.262]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:36.262]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:36.262]             base::names(...future.oldOptions))
[17:26:36.262]     }
[17:26:36.262]     if (FALSE) {
[17:26:36.262]     }
[17:26:36.262]     else {
[17:26:36.262]         if (TRUE) {
[17:26:36.262]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:36.262]                 open = "w")
[17:26:36.262]         }
[17:26:36.262]         else {
[17:26:36.262]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:36.262]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:36.262]         }
[17:26:36.262]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:36.262]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:36.262]             base::sink(type = "output", split = FALSE)
[17:26:36.262]             base::close(...future.stdout)
[17:26:36.262]         }, add = TRUE)
[17:26:36.262]     }
[17:26:36.262]     ...future.frame <- base::sys.nframe()
[17:26:36.262]     ...future.conditions <- base::list()
[17:26:36.262]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:36.262]     if (FALSE) {
[17:26:36.262]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:36.262]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:36.262]     }
[17:26:36.262]     ...future.result <- base::tryCatch({
[17:26:36.262]         base::withCallingHandlers({
[17:26:36.262]             ...future.value <- base::withVisible(base::local({
[17:26:36.262]                 ...future.makeSendCondition <- base::local({
[17:26:36.262]                   sendCondition <- NULL
[17:26:36.262]                   function(frame = 1L) {
[17:26:36.262]                     if (is.function(sendCondition)) 
[17:26:36.262]                       return(sendCondition)
[17:26:36.262]                     ns <- getNamespace("parallel")
[17:26:36.262]                     if (exists("sendData", mode = "function", 
[17:26:36.262]                       envir = ns)) {
[17:26:36.262]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:36.262]                         envir = ns)
[17:26:36.262]                       envir <- sys.frame(frame)
[17:26:36.262]                       master <- NULL
[17:26:36.262]                       while (!identical(envir, .GlobalEnv) && 
[17:26:36.262]                         !identical(envir, emptyenv())) {
[17:26:36.262]                         if (exists("master", mode = "list", envir = envir, 
[17:26:36.262]                           inherits = FALSE)) {
[17:26:36.262]                           master <- get("master", mode = "list", 
[17:26:36.262]                             envir = envir, inherits = FALSE)
[17:26:36.262]                           if (inherits(master, c("SOCKnode", 
[17:26:36.262]                             "SOCK0node"))) {
[17:26:36.262]                             sendCondition <<- function(cond) {
[17:26:36.262]                               data <- list(type = "VALUE", value = cond, 
[17:26:36.262]                                 success = TRUE)
[17:26:36.262]                               parallel_sendData(master, data)
[17:26:36.262]                             }
[17:26:36.262]                             return(sendCondition)
[17:26:36.262]                           }
[17:26:36.262]                         }
[17:26:36.262]                         frame <- frame + 1L
[17:26:36.262]                         envir <- sys.frame(frame)
[17:26:36.262]                       }
[17:26:36.262]                     }
[17:26:36.262]                     sendCondition <<- function(cond) NULL
[17:26:36.262]                   }
[17:26:36.262]                 })
[17:26:36.262]                 withCallingHandlers({
[17:26:36.262]                   1
[17:26:36.262]                 }, immediateCondition = function(cond) {
[17:26:36.262]                   sendCondition <- ...future.makeSendCondition()
[17:26:36.262]                   sendCondition(cond)
[17:26:36.262]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:36.262]                   {
[17:26:36.262]                     inherits <- base::inherits
[17:26:36.262]                     invokeRestart <- base::invokeRestart
[17:26:36.262]                     is.null <- base::is.null
[17:26:36.262]                     muffled <- FALSE
[17:26:36.262]                     if (inherits(cond, "message")) {
[17:26:36.262]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:36.262]                       if (muffled) 
[17:26:36.262]                         invokeRestart("muffleMessage")
[17:26:36.262]                     }
[17:26:36.262]                     else if (inherits(cond, "warning")) {
[17:26:36.262]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:36.262]                       if (muffled) 
[17:26:36.262]                         invokeRestart("muffleWarning")
[17:26:36.262]                     }
[17:26:36.262]                     else if (inherits(cond, "condition")) {
[17:26:36.262]                       if (!is.null(pattern)) {
[17:26:36.262]                         computeRestarts <- base::computeRestarts
[17:26:36.262]                         grepl <- base::grepl
[17:26:36.262]                         restarts <- computeRestarts(cond)
[17:26:36.262]                         for (restart in restarts) {
[17:26:36.262]                           name <- restart$name
[17:26:36.262]                           if (is.null(name)) 
[17:26:36.262]                             next
[17:26:36.262]                           if (!grepl(pattern, name)) 
[17:26:36.262]                             next
[17:26:36.262]                           invokeRestart(restart)
[17:26:36.262]                           muffled <- TRUE
[17:26:36.262]                           break
[17:26:36.262]                         }
[17:26:36.262]                       }
[17:26:36.262]                     }
[17:26:36.262]                     invisible(muffled)
[17:26:36.262]                   }
[17:26:36.262]                   muffleCondition(cond)
[17:26:36.262]                 })
[17:26:36.262]             }))
[17:26:36.262]             future::FutureResult(value = ...future.value$value, 
[17:26:36.262]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:36.262]                   ...future.rng), globalenv = if (FALSE) 
[17:26:36.262]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:36.262]                     ...future.globalenv.names))
[17:26:36.262]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:36.262]         }, condition = base::local({
[17:26:36.262]             c <- base::c
[17:26:36.262]             inherits <- base::inherits
[17:26:36.262]             invokeRestart <- base::invokeRestart
[17:26:36.262]             length <- base::length
[17:26:36.262]             list <- base::list
[17:26:36.262]             seq.int <- base::seq.int
[17:26:36.262]             signalCondition <- base::signalCondition
[17:26:36.262]             sys.calls <- base::sys.calls
[17:26:36.262]             `[[` <- base::`[[`
[17:26:36.262]             `+` <- base::`+`
[17:26:36.262]             `<<-` <- base::`<<-`
[17:26:36.262]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:36.262]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:36.262]                   3L)]
[17:26:36.262]             }
[17:26:36.262]             function(cond) {
[17:26:36.262]                 is_error <- inherits(cond, "error")
[17:26:36.262]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:36.262]                   NULL)
[17:26:36.262]                 if (is_error) {
[17:26:36.262]                   sessionInformation <- function() {
[17:26:36.262]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:36.262]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:36.262]                       search = base::search(), system = base::Sys.info())
[17:26:36.262]                   }
[17:26:36.262]                   ...future.conditions[[length(...future.conditions) + 
[17:26:36.262]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:36.262]                     cond$call), session = sessionInformation(), 
[17:26:36.262]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:36.262]                   signalCondition(cond)
[17:26:36.262]                 }
[17:26:36.262]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:36.262]                 "immediateCondition"))) {
[17:26:36.262]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:36.262]                   ...future.conditions[[length(...future.conditions) + 
[17:26:36.262]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:36.262]                   if (TRUE && !signal) {
[17:26:36.262]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:36.262]                     {
[17:26:36.262]                       inherits <- base::inherits
[17:26:36.262]                       invokeRestart <- base::invokeRestart
[17:26:36.262]                       is.null <- base::is.null
[17:26:36.262]                       muffled <- FALSE
[17:26:36.262]                       if (inherits(cond, "message")) {
[17:26:36.262]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:36.262]                         if (muffled) 
[17:26:36.262]                           invokeRestart("muffleMessage")
[17:26:36.262]                       }
[17:26:36.262]                       else if (inherits(cond, "warning")) {
[17:26:36.262]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:36.262]                         if (muffled) 
[17:26:36.262]                           invokeRestart("muffleWarning")
[17:26:36.262]                       }
[17:26:36.262]                       else if (inherits(cond, "condition")) {
[17:26:36.262]                         if (!is.null(pattern)) {
[17:26:36.262]                           computeRestarts <- base::computeRestarts
[17:26:36.262]                           grepl <- base::grepl
[17:26:36.262]                           restarts <- computeRestarts(cond)
[17:26:36.262]                           for (restart in restarts) {
[17:26:36.262]                             name <- restart$name
[17:26:36.262]                             if (is.null(name)) 
[17:26:36.262]                               next
[17:26:36.262]                             if (!grepl(pattern, name)) 
[17:26:36.262]                               next
[17:26:36.262]                             invokeRestart(restart)
[17:26:36.262]                             muffled <- TRUE
[17:26:36.262]                             break
[17:26:36.262]                           }
[17:26:36.262]                         }
[17:26:36.262]                       }
[17:26:36.262]                       invisible(muffled)
[17:26:36.262]                     }
[17:26:36.262]                     muffleCondition(cond, pattern = "^muffle")
[17:26:36.262]                   }
[17:26:36.262]                 }
[17:26:36.262]                 else {
[17:26:36.262]                   if (TRUE) {
[17:26:36.262]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:36.262]                     {
[17:26:36.262]                       inherits <- base::inherits
[17:26:36.262]                       invokeRestart <- base::invokeRestart
[17:26:36.262]                       is.null <- base::is.null
[17:26:36.262]                       muffled <- FALSE
[17:26:36.262]                       if (inherits(cond, "message")) {
[17:26:36.262]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:36.262]                         if (muffled) 
[17:26:36.262]                           invokeRestart("muffleMessage")
[17:26:36.262]                       }
[17:26:36.262]                       else if (inherits(cond, "warning")) {
[17:26:36.262]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:36.262]                         if (muffled) 
[17:26:36.262]                           invokeRestart("muffleWarning")
[17:26:36.262]                       }
[17:26:36.262]                       else if (inherits(cond, "condition")) {
[17:26:36.262]                         if (!is.null(pattern)) {
[17:26:36.262]                           computeRestarts <- base::computeRestarts
[17:26:36.262]                           grepl <- base::grepl
[17:26:36.262]                           restarts <- computeRestarts(cond)
[17:26:36.262]                           for (restart in restarts) {
[17:26:36.262]                             name <- restart$name
[17:26:36.262]                             if (is.null(name)) 
[17:26:36.262]                               next
[17:26:36.262]                             if (!grepl(pattern, name)) 
[17:26:36.262]                               next
[17:26:36.262]                             invokeRestart(restart)
[17:26:36.262]                             muffled <- TRUE
[17:26:36.262]                             break
[17:26:36.262]                           }
[17:26:36.262]                         }
[17:26:36.262]                       }
[17:26:36.262]                       invisible(muffled)
[17:26:36.262]                     }
[17:26:36.262]                     muffleCondition(cond, pattern = "^muffle")
[17:26:36.262]                   }
[17:26:36.262]                 }
[17:26:36.262]             }
[17:26:36.262]         }))
[17:26:36.262]     }, error = function(ex) {
[17:26:36.262]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:36.262]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:36.262]                 ...future.rng), started = ...future.startTime, 
[17:26:36.262]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:36.262]             version = "1.8"), class = "FutureResult")
[17:26:36.262]     }, finally = {
[17:26:36.262]         if (!identical(...future.workdir, getwd())) 
[17:26:36.262]             setwd(...future.workdir)
[17:26:36.262]         {
[17:26:36.262]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:36.262]                 ...future.oldOptions$nwarnings <- NULL
[17:26:36.262]             }
[17:26:36.262]             base::options(...future.oldOptions)
[17:26:36.262]             if (.Platform$OS.type == "windows") {
[17:26:36.262]                 old_names <- names(...future.oldEnvVars)
[17:26:36.262]                 envs <- base::Sys.getenv()
[17:26:36.262]                 names <- names(envs)
[17:26:36.262]                 common <- intersect(names, old_names)
[17:26:36.262]                 added <- setdiff(names, old_names)
[17:26:36.262]                 removed <- setdiff(old_names, names)
[17:26:36.262]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:36.262]                   envs[common]]
[17:26:36.262]                 NAMES <- toupper(changed)
[17:26:36.262]                 args <- list()
[17:26:36.262]                 for (kk in seq_along(NAMES)) {
[17:26:36.262]                   name <- changed[[kk]]
[17:26:36.262]                   NAME <- NAMES[[kk]]
[17:26:36.262]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:36.262]                     next
[17:26:36.262]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:36.262]                 }
[17:26:36.262]                 NAMES <- toupper(added)
[17:26:36.262]                 for (kk in seq_along(NAMES)) {
[17:26:36.262]                   name <- added[[kk]]
[17:26:36.262]                   NAME <- NAMES[[kk]]
[17:26:36.262]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:36.262]                     next
[17:26:36.262]                   args[[name]] <- ""
[17:26:36.262]                 }
[17:26:36.262]                 NAMES <- toupper(removed)
[17:26:36.262]                 for (kk in seq_along(NAMES)) {
[17:26:36.262]                   name <- removed[[kk]]
[17:26:36.262]                   NAME <- NAMES[[kk]]
[17:26:36.262]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:36.262]                     next
[17:26:36.262]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:36.262]                 }
[17:26:36.262]                 if (length(args) > 0) 
[17:26:36.262]                   base::do.call(base::Sys.setenv, args = args)
[17:26:36.262]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:36.262]             }
[17:26:36.262]             else {
[17:26:36.262]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:36.262]             }
[17:26:36.262]             {
[17:26:36.262]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:36.262]                   0L) {
[17:26:36.262]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:36.262]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:36.262]                   base::options(opts)
[17:26:36.262]                 }
[17:26:36.262]                 {
[17:26:36.262]                   {
[17:26:36.262]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:36.262]                     NULL
[17:26:36.262]                   }
[17:26:36.262]                   options(future.plan = NULL)
[17:26:36.262]                   if (is.na(NA_character_)) 
[17:26:36.262]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:36.262]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:36.262]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:36.262]                     .init = FALSE)
[17:26:36.262]                 }
[17:26:36.262]             }
[17:26:36.262]         }
[17:26:36.262]     })
[17:26:36.262]     if (TRUE) {
[17:26:36.262]         base::sink(type = "output", split = FALSE)
[17:26:36.262]         if (TRUE) {
[17:26:36.262]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:36.262]         }
[17:26:36.262]         else {
[17:26:36.262]             ...future.result["stdout"] <- base::list(NULL)
[17:26:36.262]         }
[17:26:36.262]         base::close(...future.stdout)
[17:26:36.262]         ...future.stdout <- NULL
[17:26:36.262]     }
[17:26:36.262]     ...future.result$conditions <- ...future.conditions
[17:26:36.262]     ...future.result$finished <- base::Sys.time()
[17:26:36.262]     ...future.result
[17:26:36.262] }
[17:26:36.267] MultisessionFuture started
[17:26:36.267] - Launch lazy future ... done
[17:26:36.268] run() for 'MultisessionFuture' ... done
[17:26:36.268] result() for ClusterFuture ...
[17:26:36.268] receiveMessageFromWorker() for ClusterFuture ...
[17:26:36.268] - Validating connection of MultisessionFuture
[17:26:36.283] - received message: FutureResult
[17:26:36.283] - Received FutureResult
[17:26:36.283] - Erased future from FutureRegistry
[17:26:36.283] result() for ClusterFuture ...
[17:26:36.283] - result already collected: FutureResult
[17:26:36.283] result() for ClusterFuture ... done
[17:26:36.284] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:36.284] result() for ClusterFuture ... done
[17:26:36.284] result() for ClusterFuture ...
[17:26:36.284] - result already collected: FutureResult
[17:26:36.284] result() for ClusterFuture ... done
d = 1
** Nested future assignments
[17:26:36.285] getGlobalsAndPackages() ...
[17:26:36.285] Searching for globals...
[17:26:36.289] - globals found: [5] '{', '<-', '%<-%', '%->%', '+'
[17:26:36.289] Searching for globals ... DONE
[17:26:36.290] Resolving globals: FALSE
[17:26:36.290] 
[17:26:36.290] - packages: [1] 'future'
[17:26:36.290] getGlobalsAndPackages() ... DONE
[17:26:36.291] run() for 'Future' ...
[17:26:36.291] - state: 'created'
[17:26:36.291] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:36.305] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:36.305] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:36.305]   - Field: 'node'
[17:26:36.306]   - Field: 'label'
[17:26:36.306]   - Field: 'local'
[17:26:36.306]   - Field: 'owner'
[17:26:36.306]   - Field: 'envir'
[17:26:36.306]   - Field: 'workers'
[17:26:36.307]   - Field: 'packages'
[17:26:36.307]   - Field: 'gc'
[17:26:36.307]   - Field: 'conditions'
[17:26:36.307]   - Field: 'persistent'
[17:26:36.307]   - Field: 'expr'
[17:26:36.307]   - Field: 'uuid'
[17:26:36.308]   - Field: 'seed'
[17:26:36.308]   - Field: 'version'
[17:26:36.308]   - Field: 'result'
[17:26:36.308]   - Field: 'asynchronous'
[17:26:36.308]   - Field: 'calls'
[17:26:36.308]   - Field: 'globals'
[17:26:36.309]   - Field: 'stdout'
[17:26:36.309]   - Field: 'earlySignal'
[17:26:36.309]   - Field: 'lazy'
[17:26:36.309]   - Field: 'state'
[17:26:36.309] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:36.310] - Launch lazy future ...
[17:26:36.310] Packages needed by the future expression (n = 1): 'future'
[17:26:36.310] Packages needed by future strategies (n = 0): <none>
[17:26:36.311] {
[17:26:36.311]     {
[17:26:36.311]         {
[17:26:36.311]             ...future.startTime <- base::Sys.time()
[17:26:36.311]             {
[17:26:36.311]                 {
[17:26:36.311]                   {
[17:26:36.311]                     {
[17:26:36.311]                       {
[17:26:36.311]                         base::local({
[17:26:36.311]                           has_future <- base::requireNamespace("future", 
[17:26:36.311]                             quietly = TRUE)
[17:26:36.311]                           if (has_future) {
[17:26:36.311]                             ns <- base::getNamespace("future")
[17:26:36.311]                             version <- ns[[".package"]][["version"]]
[17:26:36.311]                             if (is.null(version)) 
[17:26:36.311]                               version <- utils::packageVersion("future")
[17:26:36.311]                           }
[17:26:36.311]                           else {
[17:26:36.311]                             version <- NULL
[17:26:36.311]                           }
[17:26:36.311]                           if (!has_future || version < "1.8.0") {
[17:26:36.311]                             info <- base::c(r_version = base::gsub("R version ", 
[17:26:36.311]                               "", base::R.version$version.string), 
[17:26:36.311]                               platform = base::sprintf("%s (%s-bit)", 
[17:26:36.311]                                 base::R.version$platform, 8 * 
[17:26:36.311]                                   base::.Machine$sizeof.pointer), 
[17:26:36.311]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:36.311]                                 "release", "version")], collapse = " "), 
[17:26:36.311]                               hostname = base::Sys.info()[["nodename"]])
[17:26:36.311]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:26:36.311]                               info)
[17:26:36.311]                             info <- base::paste(info, collapse = "; ")
[17:26:36.311]                             if (!has_future) {
[17:26:36.311]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:36.311]                                 info)
[17:26:36.311]                             }
[17:26:36.311]                             else {
[17:26:36.311]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:36.311]                                 info, version)
[17:26:36.311]                             }
[17:26:36.311]                             base::stop(msg)
[17:26:36.311]                           }
[17:26:36.311]                         })
[17:26:36.311]                       }
[17:26:36.311]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:36.311]                       base::options(mc.cores = 1L)
[17:26:36.311]                     }
[17:26:36.311]                     base::local({
[17:26:36.311]                       for (pkg in "future") {
[17:26:36.311]                         base::loadNamespace(pkg)
[17:26:36.311]                         base::library(pkg, character.only = TRUE)
[17:26:36.311]                       }
[17:26:36.311]                     })
[17:26:36.311]                   }
[17:26:36.311]                   ...future.strategy.old <- future::plan("list")
[17:26:36.311]                   options(future.plan = NULL)
[17:26:36.311]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:36.311]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:36.311]                 }
[17:26:36.311]                 ...future.workdir <- getwd()
[17:26:36.311]             }
[17:26:36.311]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:36.311]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:36.311]         }
[17:26:36.311]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:36.311]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:36.311]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:36.311]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:36.311]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:36.311]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:36.311]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:36.311]             base::names(...future.oldOptions))
[17:26:36.311]     }
[17:26:36.311]     if (FALSE) {
[17:26:36.311]     }
[17:26:36.311]     else {
[17:26:36.311]         if (TRUE) {
[17:26:36.311]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:36.311]                 open = "w")
[17:26:36.311]         }
[17:26:36.311]         else {
[17:26:36.311]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:36.311]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:36.311]         }
[17:26:36.311]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:36.311]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:36.311]             base::sink(type = "output", split = FALSE)
[17:26:36.311]             base::close(...future.stdout)
[17:26:36.311]         }, add = TRUE)
[17:26:36.311]     }
[17:26:36.311]     ...future.frame <- base::sys.nframe()
[17:26:36.311]     ...future.conditions <- base::list()
[17:26:36.311]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:36.311]     if (FALSE) {
[17:26:36.311]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:36.311]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:36.311]     }
[17:26:36.311]     ...future.result <- base::tryCatch({
[17:26:36.311]         base::withCallingHandlers({
[17:26:36.311]             ...future.value <- base::withVisible(base::local({
[17:26:36.311]                 ...future.makeSendCondition <- base::local({
[17:26:36.311]                   sendCondition <- NULL
[17:26:36.311]                   function(frame = 1L) {
[17:26:36.311]                     if (is.function(sendCondition)) 
[17:26:36.311]                       return(sendCondition)
[17:26:36.311]                     ns <- getNamespace("parallel")
[17:26:36.311]                     if (exists("sendData", mode = "function", 
[17:26:36.311]                       envir = ns)) {
[17:26:36.311]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:36.311]                         envir = ns)
[17:26:36.311]                       envir <- sys.frame(frame)
[17:26:36.311]                       master <- NULL
[17:26:36.311]                       while (!identical(envir, .GlobalEnv) && 
[17:26:36.311]                         !identical(envir, emptyenv())) {
[17:26:36.311]                         if (exists("master", mode = "list", envir = envir, 
[17:26:36.311]                           inherits = FALSE)) {
[17:26:36.311]                           master <- get("master", mode = "list", 
[17:26:36.311]                             envir = envir, inherits = FALSE)
[17:26:36.311]                           if (inherits(master, c("SOCKnode", 
[17:26:36.311]                             "SOCK0node"))) {
[17:26:36.311]                             sendCondition <<- function(cond) {
[17:26:36.311]                               data <- list(type = "VALUE", value = cond, 
[17:26:36.311]                                 success = TRUE)
[17:26:36.311]                               parallel_sendData(master, data)
[17:26:36.311]                             }
[17:26:36.311]                             return(sendCondition)
[17:26:36.311]                           }
[17:26:36.311]                         }
[17:26:36.311]                         frame <- frame + 1L
[17:26:36.311]                         envir <- sys.frame(frame)
[17:26:36.311]                       }
[17:26:36.311]                     }
[17:26:36.311]                     sendCondition <<- function(cond) NULL
[17:26:36.311]                   }
[17:26:36.311]                 })
[17:26:36.311]                 withCallingHandlers({
[17:26:36.311]                   {
[17:26:36.311]                     b <- 1
[17:26:36.311]                     c %<-% 2
[17:26:36.311]                     d <- 3
[17:26:36.311]                     4 %->% e
[17:26:36.311]                     b + c + d + e
[17:26:36.311]                   }
[17:26:36.311]                 }, immediateCondition = function(cond) {
[17:26:36.311]                   sendCondition <- ...future.makeSendCondition()
[17:26:36.311]                   sendCondition(cond)
[17:26:36.311]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:36.311]                   {
[17:26:36.311]                     inherits <- base::inherits
[17:26:36.311]                     invokeRestart <- base::invokeRestart
[17:26:36.311]                     is.null <- base::is.null
[17:26:36.311]                     muffled <- FALSE
[17:26:36.311]                     if (inherits(cond, "message")) {
[17:26:36.311]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:36.311]                       if (muffled) 
[17:26:36.311]                         invokeRestart("muffleMessage")
[17:26:36.311]                     }
[17:26:36.311]                     else if (inherits(cond, "warning")) {
[17:26:36.311]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:36.311]                       if (muffled) 
[17:26:36.311]                         invokeRestart("muffleWarning")
[17:26:36.311]                     }
[17:26:36.311]                     else if (inherits(cond, "condition")) {
[17:26:36.311]                       if (!is.null(pattern)) {
[17:26:36.311]                         computeRestarts <- base::computeRestarts
[17:26:36.311]                         grepl <- base::grepl
[17:26:36.311]                         restarts <- computeRestarts(cond)
[17:26:36.311]                         for (restart in restarts) {
[17:26:36.311]                           name <- restart$name
[17:26:36.311]                           if (is.null(name)) 
[17:26:36.311]                             next
[17:26:36.311]                           if (!grepl(pattern, name)) 
[17:26:36.311]                             next
[17:26:36.311]                           invokeRestart(restart)
[17:26:36.311]                           muffled <- TRUE
[17:26:36.311]                           break
[17:26:36.311]                         }
[17:26:36.311]                       }
[17:26:36.311]                     }
[17:26:36.311]                     invisible(muffled)
[17:26:36.311]                   }
[17:26:36.311]                   muffleCondition(cond)
[17:26:36.311]                 })
[17:26:36.311]             }))
[17:26:36.311]             future::FutureResult(value = ...future.value$value, 
[17:26:36.311]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:36.311]                   ...future.rng), globalenv = if (FALSE) 
[17:26:36.311]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:36.311]                     ...future.globalenv.names))
[17:26:36.311]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:36.311]         }, condition = base::local({
[17:26:36.311]             c <- base::c
[17:26:36.311]             inherits <- base::inherits
[17:26:36.311]             invokeRestart <- base::invokeRestart
[17:26:36.311]             length <- base::length
[17:26:36.311]             list <- base::list
[17:26:36.311]             seq.int <- base::seq.int
[17:26:36.311]             signalCondition <- base::signalCondition
[17:26:36.311]             sys.calls <- base::sys.calls
[17:26:36.311]             `[[` <- base::`[[`
[17:26:36.311]             `+` <- base::`+`
[17:26:36.311]             `<<-` <- base::`<<-`
[17:26:36.311]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:36.311]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:36.311]                   3L)]
[17:26:36.311]             }
[17:26:36.311]             function(cond) {
[17:26:36.311]                 is_error <- inherits(cond, "error")
[17:26:36.311]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:36.311]                   NULL)
[17:26:36.311]                 if (is_error) {
[17:26:36.311]                   sessionInformation <- function() {
[17:26:36.311]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:36.311]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:36.311]                       search = base::search(), system = base::Sys.info())
[17:26:36.311]                   }
[17:26:36.311]                   ...future.conditions[[length(...future.conditions) + 
[17:26:36.311]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:36.311]                     cond$call), session = sessionInformation(), 
[17:26:36.311]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:36.311]                   signalCondition(cond)
[17:26:36.311]                 }
[17:26:36.311]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:36.311]                 "immediateCondition"))) {
[17:26:36.311]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:36.311]                   ...future.conditions[[length(...future.conditions) + 
[17:26:36.311]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:36.311]                   if (TRUE && !signal) {
[17:26:36.311]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:36.311]                     {
[17:26:36.311]                       inherits <- base::inherits
[17:26:36.311]                       invokeRestart <- base::invokeRestart
[17:26:36.311]                       is.null <- base::is.null
[17:26:36.311]                       muffled <- FALSE
[17:26:36.311]                       if (inherits(cond, "message")) {
[17:26:36.311]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:36.311]                         if (muffled) 
[17:26:36.311]                           invokeRestart("muffleMessage")
[17:26:36.311]                       }
[17:26:36.311]                       else if (inherits(cond, "warning")) {
[17:26:36.311]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:36.311]                         if (muffled) 
[17:26:36.311]                           invokeRestart("muffleWarning")
[17:26:36.311]                       }
[17:26:36.311]                       else if (inherits(cond, "condition")) {
[17:26:36.311]                         if (!is.null(pattern)) {
[17:26:36.311]                           computeRestarts <- base::computeRestarts
[17:26:36.311]                           grepl <- base::grepl
[17:26:36.311]                           restarts <- computeRestarts(cond)
[17:26:36.311]                           for (restart in restarts) {
[17:26:36.311]                             name <- restart$name
[17:26:36.311]                             if (is.null(name)) 
[17:26:36.311]                               next
[17:26:36.311]                             if (!grepl(pattern, name)) 
[17:26:36.311]                               next
[17:26:36.311]                             invokeRestart(restart)
[17:26:36.311]                             muffled <- TRUE
[17:26:36.311]                             break
[17:26:36.311]                           }
[17:26:36.311]                         }
[17:26:36.311]                       }
[17:26:36.311]                       invisible(muffled)
[17:26:36.311]                     }
[17:26:36.311]                     muffleCondition(cond, pattern = "^muffle")
[17:26:36.311]                   }
[17:26:36.311]                 }
[17:26:36.311]                 else {
[17:26:36.311]                   if (TRUE) {
[17:26:36.311]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:36.311]                     {
[17:26:36.311]                       inherits <- base::inherits
[17:26:36.311]                       invokeRestart <- base::invokeRestart
[17:26:36.311]                       is.null <- base::is.null
[17:26:36.311]                       muffled <- FALSE
[17:26:36.311]                       if (inherits(cond, "message")) {
[17:26:36.311]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:36.311]                         if (muffled) 
[17:26:36.311]                           invokeRestart("muffleMessage")
[17:26:36.311]                       }
[17:26:36.311]                       else if (inherits(cond, "warning")) {
[17:26:36.311]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:36.311]                         if (muffled) 
[17:26:36.311]                           invokeRestart("muffleWarning")
[17:26:36.311]                       }
[17:26:36.311]                       else if (inherits(cond, "condition")) {
[17:26:36.311]                         if (!is.null(pattern)) {
[17:26:36.311]                           computeRestarts <- base::computeRestarts
[17:26:36.311]                           grepl <- base::grepl
[17:26:36.311]                           restarts <- computeRestarts(cond)
[17:26:36.311]                           for (restart in restarts) {
[17:26:36.311]                             name <- restart$name
[17:26:36.311]                             if (is.null(name)) 
[17:26:36.311]                               next
[17:26:36.311]                             if (!grepl(pattern, name)) 
[17:26:36.311]                               next
[17:26:36.311]                             invokeRestart(restart)
[17:26:36.311]                             muffled <- TRUE
[17:26:36.311]                             break
[17:26:36.311]                           }
[17:26:36.311]                         }
[17:26:36.311]                       }
[17:26:36.311]                       invisible(muffled)
[17:26:36.311]                     }
[17:26:36.311]                     muffleCondition(cond, pattern = "^muffle")
[17:26:36.311]                   }
[17:26:36.311]                 }
[17:26:36.311]             }
[17:26:36.311]         }))
[17:26:36.311]     }, error = function(ex) {
[17:26:36.311]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:36.311]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:36.311]                 ...future.rng), started = ...future.startTime, 
[17:26:36.311]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:36.311]             version = "1.8"), class = "FutureResult")
[17:26:36.311]     }, finally = {
[17:26:36.311]         if (!identical(...future.workdir, getwd())) 
[17:26:36.311]             setwd(...future.workdir)
[17:26:36.311]         {
[17:26:36.311]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:36.311]                 ...future.oldOptions$nwarnings <- NULL
[17:26:36.311]             }
[17:26:36.311]             base::options(...future.oldOptions)
[17:26:36.311]             if (.Platform$OS.type == "windows") {
[17:26:36.311]                 old_names <- names(...future.oldEnvVars)
[17:26:36.311]                 envs <- base::Sys.getenv()
[17:26:36.311]                 names <- names(envs)
[17:26:36.311]                 common <- intersect(names, old_names)
[17:26:36.311]                 added <- setdiff(names, old_names)
[17:26:36.311]                 removed <- setdiff(old_names, names)
[17:26:36.311]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:36.311]                   envs[common]]
[17:26:36.311]                 NAMES <- toupper(changed)
[17:26:36.311]                 args <- list()
[17:26:36.311]                 for (kk in seq_along(NAMES)) {
[17:26:36.311]                   name <- changed[[kk]]
[17:26:36.311]                   NAME <- NAMES[[kk]]
[17:26:36.311]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:36.311]                     next
[17:26:36.311]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:36.311]                 }
[17:26:36.311]                 NAMES <- toupper(added)
[17:26:36.311]                 for (kk in seq_along(NAMES)) {
[17:26:36.311]                   name <- added[[kk]]
[17:26:36.311]                   NAME <- NAMES[[kk]]
[17:26:36.311]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:36.311]                     next
[17:26:36.311]                   args[[name]] <- ""
[17:26:36.311]                 }
[17:26:36.311]                 NAMES <- toupper(removed)
[17:26:36.311]                 for (kk in seq_along(NAMES)) {
[17:26:36.311]                   name <- removed[[kk]]
[17:26:36.311]                   NAME <- NAMES[[kk]]
[17:26:36.311]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:36.311]                     next
[17:26:36.311]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:36.311]                 }
[17:26:36.311]                 if (length(args) > 0) 
[17:26:36.311]                   base::do.call(base::Sys.setenv, args = args)
[17:26:36.311]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:36.311]             }
[17:26:36.311]             else {
[17:26:36.311]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:36.311]             }
[17:26:36.311]             {
[17:26:36.311]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:36.311]                   0L) {
[17:26:36.311]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:36.311]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:36.311]                   base::options(opts)
[17:26:36.311]                 }
[17:26:36.311]                 {
[17:26:36.311]                   {
[17:26:36.311]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:36.311]                     NULL
[17:26:36.311]                   }
[17:26:36.311]                   options(future.plan = NULL)
[17:26:36.311]                   if (is.na(NA_character_)) 
[17:26:36.311]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:36.311]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:36.311]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:36.311]                     .init = FALSE)
[17:26:36.311]                 }
[17:26:36.311]             }
[17:26:36.311]         }
[17:26:36.311]     })
[17:26:36.311]     if (TRUE) {
[17:26:36.311]         base::sink(type = "output", split = FALSE)
[17:26:36.311]         if (TRUE) {
[17:26:36.311]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:36.311]         }
[17:26:36.311]         else {
[17:26:36.311]             ...future.result["stdout"] <- base::list(NULL)
[17:26:36.311]         }
[17:26:36.311]         base::close(...future.stdout)
[17:26:36.311]         ...future.stdout <- NULL
[17:26:36.311]     }
[17:26:36.311]     ...future.result$conditions <- ...future.conditions
[17:26:36.311]     ...future.result$finished <- base::Sys.time()
[17:26:36.311]     ...future.result
[17:26:36.311] }
[17:26:36.316] MultisessionFuture started
[17:26:36.316] - Launch lazy future ... done
[17:26:36.317] run() for 'MultisessionFuture' ... done
[17:26:36.317] result() for ClusterFuture ...
[17:26:36.317] receiveMessageFromWorker() for ClusterFuture ...
[17:26:36.317] - Validating connection of MultisessionFuture
[17:26:36.350] - received message: FutureResult
[17:26:36.350] - Received FutureResult
[17:26:36.350] - Erased future from FutureRegistry
[17:26:36.350] result() for ClusterFuture ...
[17:26:36.350] - result already collected: FutureResult
[17:26:36.351] result() for ClusterFuture ... done
[17:26:36.351] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:36.351] result() for ClusterFuture ... done
[17:26:36.351] result() for ClusterFuture ...
[17:26:36.351] - result already collected: FutureResult
[17:26:36.351] result() for ClusterFuture ... done
a = 10
[17:26:36.352] getGlobalsAndPackages() ...
[17:26:36.352] Searching for globals...
[17:26:36.353] - globals found: [3] '{', '+', 'a'
[17:26:36.353] Searching for globals ... DONE
[17:26:36.353] Resolving globals: FALSE
[17:26:36.354] The total size of the 1 globals is 56 bytes (56 bytes)
[17:26:36.354] The total size of the 1 globals exported for future expression ('{; a + 1; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'a' (56 bytes of class 'numeric')
[17:26:36.354] - globals: [1] 'a'
[17:26:36.355] 
[17:26:36.355] getGlobalsAndPackages() ... DONE
[17:26:36.355] run() for 'Future' ...
[17:26:36.355] - state: 'created'
[17:26:36.356] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:36.369] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:36.369] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:36.369]   - Field: 'node'
[17:26:36.369]   - Field: 'label'
[17:26:36.370]   - Field: 'local'
[17:26:36.370]   - Field: 'owner'
[17:26:36.370]   - Field: 'envir'
[17:26:36.370]   - Field: 'workers'
[17:26:36.370]   - Field: 'packages'
[17:26:36.370]   - Field: 'gc'
[17:26:36.371]   - Field: 'conditions'
[17:26:36.371]   - Field: 'persistent'
[17:26:36.371]   - Field: 'expr'
[17:26:36.371]   - Field: 'uuid'
[17:26:36.371]   - Field: 'seed'
[17:26:36.372]   - Field: 'version'
[17:26:36.372]   - Field: 'result'
[17:26:36.372]   - Field: 'asynchronous'
[17:26:36.372]   - Field: 'calls'
[17:26:36.372]   - Field: 'globals'
[17:26:36.372]   - Field: 'stdout'
[17:26:36.373]   - Field: 'earlySignal'
[17:26:36.373]   - Field: 'lazy'
[17:26:36.373]   - Field: 'state'
[17:26:36.373] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:36.373] - Launch lazy future ...
[17:26:36.374] Packages needed by the future expression (n = 0): <none>
[17:26:36.374] Packages needed by future strategies (n = 0): <none>
[17:26:36.374] {
[17:26:36.374]     {
[17:26:36.374]         {
[17:26:36.374]             ...future.startTime <- base::Sys.time()
[17:26:36.374]             {
[17:26:36.374]                 {
[17:26:36.374]                   {
[17:26:36.374]                     {
[17:26:36.374]                       base::local({
[17:26:36.374]                         has_future <- base::requireNamespace("future", 
[17:26:36.374]                           quietly = TRUE)
[17:26:36.374]                         if (has_future) {
[17:26:36.374]                           ns <- base::getNamespace("future")
[17:26:36.374]                           version <- ns[[".package"]][["version"]]
[17:26:36.374]                           if (is.null(version)) 
[17:26:36.374]                             version <- utils::packageVersion("future")
[17:26:36.374]                         }
[17:26:36.374]                         else {
[17:26:36.374]                           version <- NULL
[17:26:36.374]                         }
[17:26:36.374]                         if (!has_future || version < "1.8.0") {
[17:26:36.374]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:36.374]                             "", base::R.version$version.string), 
[17:26:36.374]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:36.374]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:36.374]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:36.374]                               "release", "version")], collapse = " "), 
[17:26:36.374]                             hostname = base::Sys.info()[["nodename"]])
[17:26:36.374]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:36.374]                             info)
[17:26:36.374]                           info <- base::paste(info, collapse = "; ")
[17:26:36.374]                           if (!has_future) {
[17:26:36.374]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:36.374]                               info)
[17:26:36.374]                           }
[17:26:36.374]                           else {
[17:26:36.374]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:36.374]                               info, version)
[17:26:36.374]                           }
[17:26:36.374]                           base::stop(msg)
[17:26:36.374]                         }
[17:26:36.374]                       })
[17:26:36.374]                     }
[17:26:36.374]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:36.374]                     base::options(mc.cores = 1L)
[17:26:36.374]                   }
[17:26:36.374]                   ...future.strategy.old <- future::plan("list")
[17:26:36.374]                   options(future.plan = NULL)
[17:26:36.374]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:36.374]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:36.374]                 }
[17:26:36.374]                 ...future.workdir <- getwd()
[17:26:36.374]             }
[17:26:36.374]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:36.374]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:36.374]         }
[17:26:36.374]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:36.374]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:36.374]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:36.374]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:36.374]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:36.374]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:36.374]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:36.374]             base::names(...future.oldOptions))
[17:26:36.374]     }
[17:26:36.374]     if (FALSE) {
[17:26:36.374]     }
[17:26:36.374]     else {
[17:26:36.374]         if (TRUE) {
[17:26:36.374]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:36.374]                 open = "w")
[17:26:36.374]         }
[17:26:36.374]         else {
[17:26:36.374]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:36.374]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:36.374]         }
[17:26:36.374]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:36.374]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:36.374]             base::sink(type = "output", split = FALSE)
[17:26:36.374]             base::close(...future.stdout)
[17:26:36.374]         }, add = TRUE)
[17:26:36.374]     }
[17:26:36.374]     ...future.frame <- base::sys.nframe()
[17:26:36.374]     ...future.conditions <- base::list()
[17:26:36.374]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:36.374]     if (FALSE) {
[17:26:36.374]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:36.374]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:36.374]     }
[17:26:36.374]     ...future.result <- base::tryCatch({
[17:26:36.374]         base::withCallingHandlers({
[17:26:36.374]             ...future.value <- base::withVisible(base::local({
[17:26:36.374]                 ...future.makeSendCondition <- base::local({
[17:26:36.374]                   sendCondition <- NULL
[17:26:36.374]                   function(frame = 1L) {
[17:26:36.374]                     if (is.function(sendCondition)) 
[17:26:36.374]                       return(sendCondition)
[17:26:36.374]                     ns <- getNamespace("parallel")
[17:26:36.374]                     if (exists("sendData", mode = "function", 
[17:26:36.374]                       envir = ns)) {
[17:26:36.374]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:36.374]                         envir = ns)
[17:26:36.374]                       envir <- sys.frame(frame)
[17:26:36.374]                       master <- NULL
[17:26:36.374]                       while (!identical(envir, .GlobalEnv) && 
[17:26:36.374]                         !identical(envir, emptyenv())) {
[17:26:36.374]                         if (exists("master", mode = "list", envir = envir, 
[17:26:36.374]                           inherits = FALSE)) {
[17:26:36.374]                           master <- get("master", mode = "list", 
[17:26:36.374]                             envir = envir, inherits = FALSE)
[17:26:36.374]                           if (inherits(master, c("SOCKnode", 
[17:26:36.374]                             "SOCK0node"))) {
[17:26:36.374]                             sendCondition <<- function(cond) {
[17:26:36.374]                               data <- list(type = "VALUE", value = cond, 
[17:26:36.374]                                 success = TRUE)
[17:26:36.374]                               parallel_sendData(master, data)
[17:26:36.374]                             }
[17:26:36.374]                             return(sendCondition)
[17:26:36.374]                           }
[17:26:36.374]                         }
[17:26:36.374]                         frame <- frame + 1L
[17:26:36.374]                         envir <- sys.frame(frame)
[17:26:36.374]                       }
[17:26:36.374]                     }
[17:26:36.374]                     sendCondition <<- function(cond) NULL
[17:26:36.374]                   }
[17:26:36.374]                 })
[17:26:36.374]                 withCallingHandlers({
[17:26:36.374]                   {
[17:26:36.374]                     a + 1
[17:26:36.374]                   }
[17:26:36.374]                 }, immediateCondition = function(cond) {
[17:26:36.374]                   sendCondition <- ...future.makeSendCondition()
[17:26:36.374]                   sendCondition(cond)
[17:26:36.374]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:36.374]                   {
[17:26:36.374]                     inherits <- base::inherits
[17:26:36.374]                     invokeRestart <- base::invokeRestart
[17:26:36.374]                     is.null <- base::is.null
[17:26:36.374]                     muffled <- FALSE
[17:26:36.374]                     if (inherits(cond, "message")) {
[17:26:36.374]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:36.374]                       if (muffled) 
[17:26:36.374]                         invokeRestart("muffleMessage")
[17:26:36.374]                     }
[17:26:36.374]                     else if (inherits(cond, "warning")) {
[17:26:36.374]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:36.374]                       if (muffled) 
[17:26:36.374]                         invokeRestart("muffleWarning")
[17:26:36.374]                     }
[17:26:36.374]                     else if (inherits(cond, "condition")) {
[17:26:36.374]                       if (!is.null(pattern)) {
[17:26:36.374]                         computeRestarts <- base::computeRestarts
[17:26:36.374]                         grepl <- base::grepl
[17:26:36.374]                         restarts <- computeRestarts(cond)
[17:26:36.374]                         for (restart in restarts) {
[17:26:36.374]                           name <- restart$name
[17:26:36.374]                           if (is.null(name)) 
[17:26:36.374]                             next
[17:26:36.374]                           if (!grepl(pattern, name)) 
[17:26:36.374]                             next
[17:26:36.374]                           invokeRestart(restart)
[17:26:36.374]                           muffled <- TRUE
[17:26:36.374]                           break
[17:26:36.374]                         }
[17:26:36.374]                       }
[17:26:36.374]                     }
[17:26:36.374]                     invisible(muffled)
[17:26:36.374]                   }
[17:26:36.374]                   muffleCondition(cond)
[17:26:36.374]                 })
[17:26:36.374]             }))
[17:26:36.374]             future::FutureResult(value = ...future.value$value, 
[17:26:36.374]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:36.374]                   ...future.rng), globalenv = if (FALSE) 
[17:26:36.374]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:36.374]                     ...future.globalenv.names))
[17:26:36.374]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:36.374]         }, condition = base::local({
[17:26:36.374]             c <- base::c
[17:26:36.374]             inherits <- base::inherits
[17:26:36.374]             invokeRestart <- base::invokeRestart
[17:26:36.374]             length <- base::length
[17:26:36.374]             list <- base::list
[17:26:36.374]             seq.int <- base::seq.int
[17:26:36.374]             signalCondition <- base::signalCondition
[17:26:36.374]             sys.calls <- base::sys.calls
[17:26:36.374]             `[[` <- base::`[[`
[17:26:36.374]             `+` <- base::`+`
[17:26:36.374]             `<<-` <- base::`<<-`
[17:26:36.374]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:36.374]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:36.374]                   3L)]
[17:26:36.374]             }
[17:26:36.374]             function(cond) {
[17:26:36.374]                 is_error <- inherits(cond, "error")
[17:26:36.374]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:36.374]                   NULL)
[17:26:36.374]                 if (is_error) {
[17:26:36.374]                   sessionInformation <- function() {
[17:26:36.374]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:36.374]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:36.374]                       search = base::search(), system = base::Sys.info())
[17:26:36.374]                   }
[17:26:36.374]                   ...future.conditions[[length(...future.conditions) + 
[17:26:36.374]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:36.374]                     cond$call), session = sessionInformation(), 
[17:26:36.374]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:36.374]                   signalCondition(cond)
[17:26:36.374]                 }
[17:26:36.374]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:36.374]                 "immediateCondition"))) {
[17:26:36.374]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:36.374]                   ...future.conditions[[length(...future.conditions) + 
[17:26:36.374]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:36.374]                   if (TRUE && !signal) {
[17:26:36.374]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:36.374]                     {
[17:26:36.374]                       inherits <- base::inherits
[17:26:36.374]                       invokeRestart <- base::invokeRestart
[17:26:36.374]                       is.null <- base::is.null
[17:26:36.374]                       muffled <- FALSE
[17:26:36.374]                       if (inherits(cond, "message")) {
[17:26:36.374]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:36.374]                         if (muffled) 
[17:26:36.374]                           invokeRestart("muffleMessage")
[17:26:36.374]                       }
[17:26:36.374]                       else if (inherits(cond, "warning")) {
[17:26:36.374]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:36.374]                         if (muffled) 
[17:26:36.374]                           invokeRestart("muffleWarning")
[17:26:36.374]                       }
[17:26:36.374]                       else if (inherits(cond, "condition")) {
[17:26:36.374]                         if (!is.null(pattern)) {
[17:26:36.374]                           computeRestarts <- base::computeRestarts
[17:26:36.374]                           grepl <- base::grepl
[17:26:36.374]                           restarts <- computeRestarts(cond)
[17:26:36.374]                           for (restart in restarts) {
[17:26:36.374]                             name <- restart$name
[17:26:36.374]                             if (is.null(name)) 
[17:26:36.374]                               next
[17:26:36.374]                             if (!grepl(pattern, name)) 
[17:26:36.374]                               next
[17:26:36.374]                             invokeRestart(restart)
[17:26:36.374]                             muffled <- TRUE
[17:26:36.374]                             break
[17:26:36.374]                           }
[17:26:36.374]                         }
[17:26:36.374]                       }
[17:26:36.374]                       invisible(muffled)
[17:26:36.374]                     }
[17:26:36.374]                     muffleCondition(cond, pattern = "^muffle")
[17:26:36.374]                   }
[17:26:36.374]                 }
[17:26:36.374]                 else {
[17:26:36.374]                   if (TRUE) {
[17:26:36.374]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:36.374]                     {
[17:26:36.374]                       inherits <- base::inherits
[17:26:36.374]                       invokeRestart <- base::invokeRestart
[17:26:36.374]                       is.null <- base::is.null
[17:26:36.374]                       muffled <- FALSE
[17:26:36.374]                       if (inherits(cond, "message")) {
[17:26:36.374]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:36.374]                         if (muffled) 
[17:26:36.374]                           invokeRestart("muffleMessage")
[17:26:36.374]                       }
[17:26:36.374]                       else if (inherits(cond, "warning")) {
[17:26:36.374]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:36.374]                         if (muffled) 
[17:26:36.374]                           invokeRestart("muffleWarning")
[17:26:36.374]                       }
[17:26:36.374]                       else if (inherits(cond, "condition")) {
[17:26:36.374]                         if (!is.null(pattern)) {
[17:26:36.374]                           computeRestarts <- base::computeRestarts
[17:26:36.374]                           grepl <- base::grepl
[17:26:36.374]                           restarts <- computeRestarts(cond)
[17:26:36.374]                           for (restart in restarts) {
[17:26:36.374]                             name <- restart$name
[17:26:36.374]                             if (is.null(name)) 
[17:26:36.374]                               next
[17:26:36.374]                             if (!grepl(pattern, name)) 
[17:26:36.374]                               next
[17:26:36.374]                             invokeRestart(restart)
[17:26:36.374]                             muffled <- TRUE
[17:26:36.374]                             break
[17:26:36.374]                           }
[17:26:36.374]                         }
[17:26:36.374]                       }
[17:26:36.374]                       invisible(muffled)
[17:26:36.374]                     }
[17:26:36.374]                     muffleCondition(cond, pattern = "^muffle")
[17:26:36.374]                   }
[17:26:36.374]                 }
[17:26:36.374]             }
[17:26:36.374]         }))
[17:26:36.374]     }, error = function(ex) {
[17:26:36.374]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:36.374]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:36.374]                 ...future.rng), started = ...future.startTime, 
[17:26:36.374]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:36.374]             version = "1.8"), class = "FutureResult")
[17:26:36.374]     }, finally = {
[17:26:36.374]         if (!identical(...future.workdir, getwd())) 
[17:26:36.374]             setwd(...future.workdir)
[17:26:36.374]         {
[17:26:36.374]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:36.374]                 ...future.oldOptions$nwarnings <- NULL
[17:26:36.374]             }
[17:26:36.374]             base::options(...future.oldOptions)
[17:26:36.374]             if (.Platform$OS.type == "windows") {
[17:26:36.374]                 old_names <- names(...future.oldEnvVars)
[17:26:36.374]                 envs <- base::Sys.getenv()
[17:26:36.374]                 names <- names(envs)
[17:26:36.374]                 common <- intersect(names, old_names)
[17:26:36.374]                 added <- setdiff(names, old_names)
[17:26:36.374]                 removed <- setdiff(old_names, names)
[17:26:36.374]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:36.374]                   envs[common]]
[17:26:36.374]                 NAMES <- toupper(changed)
[17:26:36.374]                 args <- list()
[17:26:36.374]                 for (kk in seq_along(NAMES)) {
[17:26:36.374]                   name <- changed[[kk]]
[17:26:36.374]                   NAME <- NAMES[[kk]]
[17:26:36.374]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:36.374]                     next
[17:26:36.374]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:36.374]                 }
[17:26:36.374]                 NAMES <- toupper(added)
[17:26:36.374]                 for (kk in seq_along(NAMES)) {
[17:26:36.374]                   name <- added[[kk]]
[17:26:36.374]                   NAME <- NAMES[[kk]]
[17:26:36.374]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:36.374]                     next
[17:26:36.374]                   args[[name]] <- ""
[17:26:36.374]                 }
[17:26:36.374]                 NAMES <- toupper(removed)
[17:26:36.374]                 for (kk in seq_along(NAMES)) {
[17:26:36.374]                   name <- removed[[kk]]
[17:26:36.374]                   NAME <- NAMES[[kk]]
[17:26:36.374]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:36.374]                     next
[17:26:36.374]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:36.374]                 }
[17:26:36.374]                 if (length(args) > 0) 
[17:26:36.374]                   base::do.call(base::Sys.setenv, args = args)
[17:26:36.374]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:36.374]             }
[17:26:36.374]             else {
[17:26:36.374]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:36.374]             }
[17:26:36.374]             {
[17:26:36.374]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:36.374]                   0L) {
[17:26:36.374]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:36.374]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:36.374]                   base::options(opts)
[17:26:36.374]                 }
[17:26:36.374]                 {
[17:26:36.374]                   {
[17:26:36.374]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:36.374]                     NULL
[17:26:36.374]                   }
[17:26:36.374]                   options(future.plan = NULL)
[17:26:36.374]                   if (is.na(NA_character_)) 
[17:26:36.374]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:36.374]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:36.374]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:36.374]                     .init = FALSE)
[17:26:36.374]                 }
[17:26:36.374]             }
[17:26:36.374]         }
[17:26:36.374]     })
[17:26:36.374]     if (TRUE) {
[17:26:36.374]         base::sink(type = "output", split = FALSE)
[17:26:36.374]         if (TRUE) {
[17:26:36.374]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:36.374]         }
[17:26:36.374]         else {
[17:26:36.374]             ...future.result["stdout"] <- base::list(NULL)
[17:26:36.374]         }
[17:26:36.374]         base::close(...future.stdout)
[17:26:36.374]         ...future.stdout <- NULL
[17:26:36.374]     }
[17:26:36.374]     ...future.result$conditions <- ...future.conditions
[17:26:36.374]     ...future.result$finished <- base::Sys.time()
[17:26:36.374]     ...future.result
[17:26:36.374] }
[17:26:36.379] Exporting 1 global objects (56 bytes) to cluster node #1 ...
[17:26:36.380] Exporting 'a' (56 bytes) to cluster node #1 ...
[17:26:36.380] Exporting 'a' (56 bytes) to cluster node #1 ... DONE
[17:26:36.380] Exporting 1 global objects (56 bytes) to cluster node #1 ... DONE
[17:26:36.381] MultisessionFuture started
[17:26:36.381] - Launch lazy future ... done
[17:26:36.381] run() for 'MultisessionFuture' ... done
[17:26:36.381] result() for ClusterFuture ...
[17:26:36.381] receiveMessageFromWorker() for ClusterFuture ...
[17:26:36.382] - Validating connection of MultisessionFuture
[17:26:36.396] - received message: FutureResult
[17:26:36.396] - Received FutureResult
[17:26:36.396] - Erased future from FutureRegistry
[17:26:36.397] result() for ClusterFuture ...
[17:26:36.397] - result already collected: FutureResult
[17:26:36.397] result() for ClusterFuture ... done
[17:26:36.397] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:36.397] result() for ClusterFuture ... done
[17:26:36.397] result() for ClusterFuture ...
[17:26:36.397] - result already collected: FutureResult
[17:26:36.398] result() for ClusterFuture ... done
b = 11
*** %<-% with 'multisession' futures ... DONE
Testing with 2 cores ... DONE
> 
> message("*** %<-% ... DONE")
*** %<-% ... DONE
> 
> source("incl/end.R")
[17:26:36.399] plan(): Setting new future strategy stack:
[17:26:36.399] List of future strategies:
[17:26:36.399] 1. FutureStrategy:
[17:26:36.399]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:36.399]    - tweaked: FALSE
[17:26:36.399]    - call: future::plan(oplan)
[17:26:36.400] plan(): nbrOfWorkers() = 1
Failed to undo environment variables:
 - Expected environment variables: [n=204] '!ExitCode', 'ALLUSERSPROFILE', 'APPDATA', 'BIBINPUTS', 'BINDIR', 'BSTINPUTS', 'COMMONPROGRAMFILES', 'COMPUTERNAME', 'COMSPEC', 'CURL_CA_BUNDLE', 'CYGWIN', 'CommonProgramFiles(x86)', 'CommonProgramW6432', 'DriverData', 'HOME', 'HOMEDRIVE', 'HOMEPATH', 'JAGS_ROOT', 'JAVA_HOME', 'LANGUAGE', 'LC_COLLATE', 'LC_MONETARY', 'LC_TIME', 'LOCALAPPDATA', 'LOGONSERVER', 'LS_HOME', 'LS_LICENSE_PATH', 'MAKE', 'MAKEFLAGS', 'MAKELEVEL', 'MFLAGS', 'MSMPI_BENCHMARKS', 'MSMPI_BIN', 'MSYS2_ENV_CONV_EXCL', 'NUMBER_OF_PROCESSORS', 'OCL', 'OMP_THREAD_LIMIT', 'OS', 'PATH', 'PATHEXT', 'PROCESSOR_ARCHITECTURE', 'PROCESSOR_IDENTIFIER', 'PROCESSOR_LEVEL', 'PROCESSOR_REVISION', 'PROGRAMFILES', 'PROMPT', 'PSModulePath', 'PUBLIC', 'PWD', 'ProgramData', 'ProgramFiles(x86)', 'ProgramW6432', 'RTOOLS43_HOME', 'RTOOLS44_HOME', 'R_ARCH', 'R_BROWSER', 'R_BZIPCMD', 'R_CMD', 'R_COMPILED_BY', 'R_CRAN_WEB', 'R_CUSTOM_TOOLS_PATH', 'R_CUSTOM_TOOLS_SOFT', 'R_DOC_DIR', 'R_ENVIRON_USER', 'R_GSCMD', 'R_GZIPCMD', 'R_HOME', 'R_INCLUDE_DIR', 'R_INSTALL_TAR', 'R_LIBS', 'R_LIBS_SITE', 'R_LIBS_USER', 'R_MAX_NUM_DLLS', 'R_OSTYPE', 'R_PAPERSIZE', 'R_PAPERSIZE_USER', 'R_PARALLELLY_MAKENODEPSOCK_AUTOKILL', 'R_PARALLELLY_MAKENODEPSOCK_CONNECTTIMEOUT', 'R_PARALLELLY_MAKENODEPSOCK_RSCRIPT_LABEL', 'R_PARALLELLY_MAKENODEPSOCK_SESSIONINFO_PKGS', 'R_PARALLELLY_MAKENODEPSOCK_TIMEOUT', 'R_PARALLELLY_RANDOM_PORTS', 'R_PARALLEL_PORT', 'R_RD4PDF', 'R_RTOOLS44_PATH', 'R_SCRIPT_LEGACY', 'R_SHARE_DIR', 'R_TESTS', 'R_UNZIPCMD', 'R_USER', 'R_VERSION', 'R_ZIPCMD', 'SED', 'SHLVL', 'SYSTEMDRIVE', 'SYSTEMROOT', 'TAR', 'TAR_OPTIONS', 'TEMP', 'TERM', 'TEXINPUTS', 'TMP', 'TMPDIR', 'USERDOMAIN', 'USERDOMAIN_ROAMINGPROFILE', 'USERNAME', 'USERPROFILE', 'WINDIR', '_', '_R_CHECK_AUTOCONF_', '_R_CHECK_BOGUS_RETURN_', '_R_CHECK_BROWSER_NONINTERACTIVE_', '_R_CHECK_BUILD_VIGNETTES_SEPARATELY_', '_R_CHECK_CODETOOLS_PROFILE_', '_R_CHECK_CODE_ASSIGN_TO_GLOBALENV_', '_R_CHECK_CODE_ATTACH_', '_R_CHECK_CODE_CLASS_IS_STRING_', '_R_CHECK_CODE_DATA_INTO_GLOBALENV_', '_R_CHECK_CODE_USAGE_VIA_NAMESPACES_', '_R_CHECK_CODE_USAGE_WITHOUT_LOADING_', '_R_CHECK_CODE_USAGE_WITH_ONLY_BASE_ATTACHED_', '_R_CHECK_CODOC_VARIABLES_IN_USAGES_', '_R_CHECK_COMPACT_DATA2_', '_R_CHECK_COMPILATION_FLAGS_', '_R_CHECK_CONNECTIONS_LEFT_OPEN_', '_R_CHECK_CRAN_INCOMING_', '_R_CHECK_CRAN_INCOMING_CHECK_FILE_URIS_', '_R_CHECK_CRAN_INCOMING_CHECK_URLS_IN_PARALLEL_', '_R_CHECK_CRAN_INCOMING_NOTE_GNU_MAKE_', '_R_CHECK_CRAN_INCOMING_REMOTE_', '_R_CHECK_CRAN_INCOMING_USE_ASPELL_', '_R_CHECK_DATALIST_', '_R_CHECK_DEPRECATED_DEFUNCT_', '_R_CHECK_DOC_SIZES2_', '_R_CHECK_DOT_FIRSTLIB_', '_R_CHECK_DOT_INTERNAL_', '_R_CHECK_EXAMPLE_TIMING_THRESHOLD_', '_R_CHECK_EXECUTABLES_', '_R_CHECK_EXECUTABLES_EXCLUSIONS_', '_R_CHECK_FF_CALLS_', '_R_CHECK_FF_DUP_', '_R_CHECK_FORCE_SUGGESTS_', '_R_CHECK_FUTURE_FILE_TIMESTAMPS_', '_R_CHECK_FUTURE_FILE_TIMESTAMPS_LEEWAY_', '_R_CHECK_HAVE_MYSQL_', '_R_CHECK_HAVE_ODBC_', '_R_CHECK_HAVE_PERL_', '_R_CHECK_HAVE_POSTGRES_', '_R_CHECK_INSTALL_DEPENDS_', '_R_CHECK_INTERNALS2_', '_R_CHECK_LENGTH_1_CONDITION_', '_R_CHECK_LICENSE_', '_R_CHECK_LIMIT_CORES_', '_R_CHECK_MATRIX_DATA_', '_R_CHECK_MBCS_CONVERSION_FAILURE_', '_R_CHECK_NATIVE_ROUTINE_REGISTRATION_', '_R_CHECK_NEWS_IN_PLAIN_TEXT_', '_R_CHECK_NO_RECOMMENDED_', '_R_CHECK_NO_STOP_ON_TEST_ERROR_', '_R_CHECK_ORPHANED_', '_R_CHECK_OVERWRITE_REGISTERED_S3_METHODS_', '_R_CHECK_PACKAGES_USED_IGNORE_UNUSED_IMPORTS_', '_R_CHECK_PACKAGES_USED_IN_TESTS_USE_SUBDIRS_', '_R_CHECK_PACKAGE_DATASETS_SUPPRESS_NOTES_', '_R_CHECK_PACKAGE_NAME_', '_R_CHECK_PKG_SIZES_', '_R_CHECK_PKG_SIZES_THRESHOLD_', '_R_CHECK_PRAGMAS_', '_R_CHECK_RD_EXAMPLES_T_AND_F_', '_R_CHECK_RD_LINE_WIDTHS_', '_R_CHECK_RD_MATH_RENDERING_', '_R_CHECK_RD_NOTE_LOST_BRACES_', '_R_CHECK_RD_VALIDATE_RD2HTML_', '_R_CHECK_REPLACING_IMPORTS_', '_R_CHECK_R_DEPENDS_', '_R_CHECK_S3_METHODS_SHOW_POSSIBLE_ISSUES_', '_R_CHECK_SCREEN_DEVICE_', '_R_CHECK_SERIALIZATION_', '_R_CHECK_SHLIB_OPENMP_FLAGS_', '_R_CHECK_SRC_MINUS_W_IMPLICIT_', '_R_CHECK_SUBDIRS_NOCASE_', '_R_CHECK_SUGGESTS_ONLY_', '_R_CHECK_SYSTEM_CLOCK_', '_R_CHECK_TESTS_NLINES_', '_R_CHECK_TEST_TIMING_', '_R_CHECK_TIMINGS_', '_R_CHECK_TOPLEVEL_FILES_', '_R_CHECK_UNDOC_USE_ALL_NAMES_', '_R_CHECK_UNSAFE_CALLS_', '_R_CHECK_URLS_SHOW_301_STATUS_', '_R_CHECK_VC_DIRS_', '_R_CHECK_VIGNETTES_NLINES_', '_R_CHECK_VIGNETTES_SKIP_RUN_MAYBE_', '_R_CHECK_VIGNETTE_TIMING_', '_R_CHECK_VIGNETTE_TITLES_', '_R_CHECK_WINDOWS_DEVICE_', '_R_CHECK_XREFS_USE_ALIASES_FROM_CRAN_', '_R_CLASS_MATRIX_ARRAY_', '_R_DEPRECATED_IS_R_', '_R_S3_METHOD_LOOKUP_BASEENV_AFTER_GLOBALENV_', '_R_SHLIB_BUILD_OBJECTS_SYMBOL_TABLES_', '__R_CHECK_DOC_FILES_NOTE_IF_ALL_SPECIAL__', 'maj.version', 'nextArg--timingsnextArg--install'
 - Environment variables still there: [n=0] 
 - Environment variables missing: [n=1] 'MAKEFLAGS'
Differences environment variable by environment variable:
List of 3
 $ name    : chr "MAKEFLAGS"
 $ expected: 'Dlist' chr ""
 $ actual  : 'Dlist' chr NA
> 
> proc.time()
   user  system elapsed 
   1.03    0.14    2.10