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

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

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

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

> source("incl/start.R")
[17:29:03.134] plan(): Setting new future strategy stack:
[17:29:03.137] List of future strategies:
[17:29:03.137] 1. sequential:
[17:29:03.137]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:03.137]    - tweaked: FALSE
[17:29:03.137]    - call: future::plan("sequential")
[17:29:03.163] plan(): nbrOfWorkers() = 1
> library("listenv")
> 
> strategies <- supportedStrategies()
> 
> message("*** resolve() ...")
*** resolve() ...
> 
> message("*** resolve() for default ...")
*** resolve() for default ...
> 
> x <- 1
> y <- resolve(x)
> stopifnot(identical(y, x))
> 
> message("*** resolve() for default ... DONE")
*** resolve() for default ... DONE
> 
> 
> for (strategy in strategies) {
+   message(sprintf("- plan('%s') ...", strategy))
+   plan(strategy)
+ 
+   if (strategy == "multisession" && availableCores() >= 2) {
+     message("*** resolve() for Future objects ...")
+     
+     for (result in c(FALSE, TRUE)) {
+       for (recursive in list(FALSE, TRUE, -1, 0, 1, 2, Inf)) {
+         message(sprintf("- result = %s, recursive = %s ...", result, recursive))
+       
+         f <- future({
+           Sys.sleep(0.5)
+           list(a = 1, b = 42L)
+         })
+         res <- resolve(f, result = result, recursive = recursive)
+         stopifnot(identical(res, f))
+     
+         f <- future({
+           Sys.sleep(0.5)
+           list(a = 1, b = 42L)
+         }, lazy = TRUE)
+         res <- resolve(f, result = result, recursive = recursive)
+         stopifnot(identical(res, f))
+     
+         message("- w/ exception ...")
+         f <- future(list(a = 1, b = 42L, c = stop("Nah!")))
+         res <- resolve(f, result = result, recursive = recursive)
+         stopifnot(identical(res, f))
+     
+         f <- future(list(a = 1, b = 42L, c = stop("Nah!")), lazy = TRUE)
+         res <- resolve(f, result = result, recursive = recursive)
+         stopifnot(identical(res, f))
+     
+         message(sprintf("- result = %s, recursive = %s ... DONE", result, recursive))
+       } ## for (resolve ...)
+     } ## for (result ...)
+     
+     message("*** resolve() for Future objects ... DONE")
+   } ## if (strategy == "multisession" && availableCores() >= 2)
+   
+   message("*** resolve() for lists ...")
+ 
+   x <- list()
+   y <- resolve(x)
+   stopifnot(identical(y, x))
+ 
+   x <- list()
+   x$a <- 1
+   x$b <- 2
+   y <- resolve(x)
+   stopifnot(identical(y, x))
+ 
+   x <- list()
+   x$a <- future(1)
+   x$b <- future(2)
+   x[[3]] <- 3
+   y <- resolve(x)
+   stopifnot(identical(y, x))
+   stopifnot(resolved(x$a))
+   stopifnot(resolved(x[["b"]]))
+ 
+   x <- list()
+   x$a <- future(1, lazy = TRUE)
+   x$b <- future(2)
+   x[[3]] <- 3
+   y <- resolve(x)
+   stopifnot(identical(y, x))
+   stopifnot(resolved(x$a))
+   stopifnot(resolved(x[["b"]]))
+ 
+   x <- list()
+   x$a <- future(1, lazy = TRUE)
+   x$b <- future(2, lazy = TRUE)
+   x[[3]] <- 3
+   y <- resolve(x)
+   stopifnot(identical(y, x))
+   stopifnot(resolved(x$a))
+   stopifnot(resolved(x[["b"]]))
+ 
+   x <- list()
+   x$a <- future(1)
+   x$b <- future({Sys.sleep(0.5); 2})
+   x[[4]] <- 4
+   dim(x) <- c(2, 2)
+   y <- resolve(x, idxs = 1)
+   stopifnot(identical(y, x))
+   stopifnot(resolved(x[[1]]))
+   y <- resolve(x, idxs = 2)
+   stopifnot(identical(y, x))
+   stopifnot(resolved(x[[2]]))
+   y <- resolve(x, idxs = 3)
+   stopifnot(identical(y, x))
+   y <- resolve(x, idxs = seq_along(x))
+   stopifnot(identical(y, x))
+   y <- resolve(x, idxs = names(x))
+   stopifnot(identical(y, x))
+ 
+   y <- resolve(x, idxs = matrix(c(1, 2), ncol = 2L), result = TRUE)
+   stopifnot(identical(y, x))
+ 
+   x <- list()
+   for (kk in 1:3) x[[kk]] <- future({ Sys.sleep(0.1); kk })
+   y <- resolve(x)
+   stopifnot(identical(y, x))
+ 
+   x <- list()
+   for (kk in 1:3) x[[kk]] <- future({ Sys.sleep(0.1); kk }, lazy = TRUE)
+   y <- resolve(x)
+   stopifnot(identical(y, x))
+ 
+   ## Exceptions
+   x <- list()
+   x$a <- 1
+   x$b <- 2
+ 
+   res <- tryCatch(y <- resolve(x, idxs = 0L), error = identity)
+   stopifnot(inherits(res, "error"))
+ 
+   res <- tryCatch(y <- resolve(x, idxs = "unknown"), error = identity)
+   stopifnot(inherits(res, "error"))
+ 
+   x <- list(1, 2)
+   res <- tryCatch(x <- resolve(x, idxs = "a"), error = identity)
+   stopifnot(inherits(res, "error"))
+ 
+   message("*** resolve() for lists ... DONE")
+ 
+ 
+   message("*** resolve() for environments ...")
+ 
+   x <- new.env()
+   y <- resolve(x)
+   stopifnot(identical(y, x))
+ 
+   x <- new.env()
+   x$a <- 1
+   x$b <- 2
+   y <- resolve(x)
+   stopifnot(identical(y, x))
+   stopifnot(length(futureOf(envir = x, drop = TRUE)) == 0L)
+ 
+   x <- new.env()
+   x$a <- future(1)
+   x$b <- future(2)
+   x$c <- 3
+   stopifnot(length(futureOf(envir = x, drop = TRUE)) == 2L)
+   y <- resolve(x)
+   stopifnot(identical(y, x))
+   stopifnot(resolved(x$a))
+   stopifnot(resolved(x$b))
+   stopifnot(length(futureOf(envir = x, drop = TRUE)) == 2L)
+ 
+   x <- new.env()
+   x$a %<-% { 1 }
+   x$b %<-% { 2 }
+   x$c <- 3
+   stopifnot(length(futureOf(envir = x, drop = TRUE)) == 2L)
+   y <- resolve(x)  ## FIXME: Should not do value()!
+   stopifnot(identical(y, x))
+   stopifnot(length(futureOf(envir = x, drop = TRUE)) == 2L)
+ 
+   x <- new.env()
+   x$a <- future({ 1 })
+   x$b %<-% { 2 }
+   x$c <- 3
+   stopifnot(length(futureOf(envir = x, drop = TRUE)) == 2L)
+   y <- resolve(x, idxs = "a")
+   stopifnot(identical(y, x))
+   stopifnot(resolved(x$a))
+   stopifnot(length(futureOf(envir = x, drop = TRUE)) == 2L)
+   y <- resolve(x, idxs = "b")
+   stopifnot(identical(y, x))
+   stopifnot(length(futureOf(envir = x, drop = TRUE)) == 2L)
+   y <- resolve(x, idxs = "c")
+   stopifnot(identical(y, x))
+   stopifnot(length(futureOf(envir = x, drop = TRUE)) == 2L)
+   y <- resolve(x, idxs = names(x), result = TRUE)
+   stopifnot(identical(y, x))
+   stopifnot(length(futureOf(envir = x, drop = TRUE)) == 2L)
+   y <- resolve(x, recursive = TRUE, result = TRUE)
+   stopifnot(identical(y, x))
+ 
+   ## Exceptions
+   res <- tryCatch(y <- resolve(x, idxs = "unknown"), error = identity)
+   stopifnot(inherits(res, "error"))
+ 
+   message("*** resolve() for environments ... DONE")
+ 
+ 
+   message("*** resolve() for list environments ...")
+ 
+   x <- listenv()
+   y <- resolve(x)
+   stopifnot(identical(y, x))
+ 
+   x <- listenv()
+   x$a <- 1
+   x$b <- 2
+   stopifnot(length(futureOf(envir = x, drop = TRUE)) == 0L)
+   y <- resolve(x)
+   stopifnot(identical(y, x))
+ 
+   x <- listenv()
+   x$a <- future(1)
+   x$b <- future(2)
+   x$c <- 3
+   names <- names(x)
+   dim(x) <- c(1, 3)
+   names(x) <- names
+   stopifnot(length(futureOf(envir = x, drop = TRUE)) == 2L)
+   y <- resolve(x)
+   stopifnot(identical(y, x))
+   stopifnot(length(futureOf(envir = x, drop = TRUE)) == 2L)
+ 
+   x <- listenv()
+   x$a %<-% { 1 }
+   x$b %<-% { 2 }
+   x$c <- 3
+   stopifnot(length(futureOf(envir = x, drop = TRUE)) == 2L)
+   y <- resolve(x)  ## FIXME: Should not do value()!
+   stopifnot(identical(y, x))
+   #stopifnot(is.na(futureOf(x$a, mustExist = FALSE)))
+   #stopifnot(is.na(futureOf(x$b, mustExist = FALSE)))
+   stopifnot(length(futureOf(envir = x, drop = TRUE)) == 2L)
+ 
+   x <- listenv()
+   x$a <- future({ 1 })
+   x$b %<-% { Sys.sleep(0.5); 2 }
+   x$c %<-% { 3 }
+   x$d <- 4
+   names <- names(x)
+   dim(x) <- c(2, 2)
+   names(x) <- names
+   stopifnot(length(futureOf(envir = x, drop = TRUE)) == 3L)
+   y <- resolve(x, idxs = "a")
+   stopifnot(identical(y, x))
+   stopifnot(identical(futureOf(x$a, mustExist = FALSE), x$a))
+   stopifnot(resolved(x$a))
+   y <- resolve(x, idxs = "b")
+   stopifnot(identical(y, x))
+   stopifnot(length(futureOf(envir = x, drop = TRUE)) == 3L)
+ 
+   idxs <- matrix(c(1, 2), ncol = 2L)
+   y <- resolve(x, idxs = idxs)
+   stopifnot(identical(y, x))
+   #stopifnot(is.na(futureOf(x$c, mustExist = FALSE)))
+   stopifnot(length(futureOf(envir = x, drop = TRUE)) == 3L)
+ 
+   y <- resolve(x, idxs = 4L)
+   stopifnot(identical(y, x))
+   #stopifnot(is.na(futureOf(x[[4L]], mustExist = FALSE)))
+   stopifnot(length(futureOf(envir = x, drop = TRUE)) == 3L)
+ 
+   y <- resolve(x, idxs = names(x), result = TRUE)
+   stopifnot(identical(y, x))
+   stopifnot(length(futureOf(envir = x, drop = TRUE)) == 3L)
+ 
+   y <- resolve(x, recursive = TRUE, result = TRUE)
+   stopifnot(identical(y, x))
+ 
+   ## Exceptions
+   res <- tryCatch(y <- resolve(x, idxs = 0L), error = identity)
+   stopifnot(inherits(res, "error"))
+ 
+   res <- tryCatch(y <- resolve(x, idxs = "unknown"), error = identity)
+   stopifnot(inherits(res, "error"))
+ 
+   message("*** resolve() for list environments ... DONE")
+ 
+   message(sprintf("- plan('%s') ...", strategy))
+ } ## for (strategy ...)
- plan('sequential') ...
[17:29:03.657] plan(): Setting new future strategy stack:
[17:29:03.657] List of future strategies:
[17:29:03.657] 1. sequential:
[17:29:03.657]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:03.657]    - tweaked: FALSE
[17:29:03.657]    - call: plan(strategy)
[17:29:03.683] plan(): nbrOfWorkers() = 1
*** resolve() for lists ...
[17:29:03.684] resolve() on list ...
[17:29:03.684]  recursive: 0
[17:29:03.685]  length: 2
[17:29:03.685]  elements: 'a', 'b'
[17:29:03.685]  length: 1 (resolved future 1)
[17:29:03.685]  length: 0 (resolved future 2)
[17:29:03.686] resolve() on list ... DONE
[17:29:03.687] getGlobalsAndPackages() ...
[17:29:03.687] Searching for globals...
[17:29:03.690] 
[17:29:03.691] Searching for globals ... DONE
[17:29:03.691] - globals: [0] <none>
[17:29:03.691] getGlobalsAndPackages() ... DONE
[17:29:03.692] run() for 'Future' ...
[17:29:03.693] - state: 'created'
[17:29:03.693] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:03.694] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:03.694] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:03.695]   - Field: 'label'
[17:29:03.695]   - Field: 'local'
[17:29:03.696]   - Field: 'owner'
[17:29:03.696]   - Field: 'envir'
[17:29:03.696]   - Field: 'packages'
[17:29:03.696]   - Field: 'gc'
[17:29:03.697]   - Field: 'conditions'
[17:29:03.697]   - Field: 'expr'
[17:29:03.697]   - Field: 'uuid'
[17:29:03.698]   - Field: 'seed'
[17:29:03.698]   - Field: 'version'
[17:29:03.698]   - Field: 'result'
[17:29:03.699]   - Field: 'asynchronous'
[17:29:03.699]   - Field: 'calls'
[17:29:03.699]   - Field: 'globals'
[17:29:03.700]   - Field: 'stdout'
[17:29:03.700]   - Field: 'earlySignal'
[17:29:03.700]   - Field: 'lazy'
[17:29:03.701]   - Field: 'state'
[17:29:03.701] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:03.701] - Launch lazy future ...
[17:29:03.703] Packages needed by the future expression (n = 0): <none>
[17:29:03.703] Packages needed by future strategies (n = 0): <none>
[17:29:03.705] {
[17:29:03.705]     {
[17:29:03.705]         {
[17:29:03.705]             ...future.startTime <- base::Sys.time()
[17:29:03.705]             {
[17:29:03.705]                 {
[17:29:03.705]                   {
[17:29:03.705]                     base::local({
[17:29:03.705]                       has_future <- base::requireNamespace("future", 
[17:29:03.705]                         quietly = TRUE)
[17:29:03.705]                       if (has_future) {
[17:29:03.705]                         ns <- base::getNamespace("future")
[17:29:03.705]                         version <- ns[[".package"]][["version"]]
[17:29:03.705]                         if (is.null(version)) 
[17:29:03.705]                           version <- utils::packageVersion("future")
[17:29:03.705]                       }
[17:29:03.705]                       else {
[17:29:03.705]                         version <- NULL
[17:29:03.705]                       }
[17:29:03.705]                       if (!has_future || version < "1.8.0") {
[17:29:03.705]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:03.705]                           "", base::R.version$version.string), 
[17:29:03.705]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:03.705]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:03.705]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:03.705]                             "release", "version")], collapse = " "), 
[17:29:03.705]                           hostname = base::Sys.info()[["nodename"]])
[17:29:03.705]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:03.705]                           info)
[17:29:03.705]                         info <- base::paste(info, collapse = "; ")
[17:29:03.705]                         if (!has_future) {
[17:29:03.705]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:03.705]                             info)
[17:29:03.705]                         }
[17:29:03.705]                         else {
[17:29:03.705]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:03.705]                             info, version)
[17:29:03.705]                         }
[17:29:03.705]                         base::stop(msg)
[17:29:03.705]                       }
[17:29:03.705]                     })
[17:29:03.705]                   }
[17:29:03.705]                   ...future.strategy.old <- future::plan("list")
[17:29:03.705]                   options(future.plan = NULL)
[17:29:03.705]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:03.705]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:03.705]                 }
[17:29:03.705]                 ...future.workdir <- getwd()
[17:29:03.705]             }
[17:29:03.705]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:03.705]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:03.705]         }
[17:29:03.705]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:03.705]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:03.705]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:03.705]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:03.705]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:03.705]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:03.705]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:03.705]             base::names(...future.oldOptions))
[17:29:03.705]     }
[17:29:03.705]     if (FALSE) {
[17:29:03.705]     }
[17:29:03.705]     else {
[17:29:03.705]         if (TRUE) {
[17:29:03.705]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:03.705]                 open = "w")
[17:29:03.705]         }
[17:29:03.705]         else {
[17:29:03.705]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:03.705]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:03.705]         }
[17:29:03.705]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:03.705]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:03.705]             base::sink(type = "output", split = FALSE)
[17:29:03.705]             base::close(...future.stdout)
[17:29:03.705]         }, add = TRUE)
[17:29:03.705]     }
[17:29:03.705]     ...future.frame <- base::sys.nframe()
[17:29:03.705]     ...future.conditions <- base::list()
[17:29:03.705]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:03.705]     if (FALSE) {
[17:29:03.705]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:03.705]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:03.705]     }
[17:29:03.705]     ...future.result <- base::tryCatch({
[17:29:03.705]         base::withCallingHandlers({
[17:29:03.705]             ...future.value <- base::withVisible(base::local(1))
[17:29:03.705]             future::FutureResult(value = ...future.value$value, 
[17:29:03.705]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:03.705]                   ...future.rng), globalenv = if (FALSE) 
[17:29:03.705]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:03.705]                     ...future.globalenv.names))
[17:29:03.705]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:03.705]         }, condition = base::local({
[17:29:03.705]             c <- base::c
[17:29:03.705]             inherits <- base::inherits
[17:29:03.705]             invokeRestart <- base::invokeRestart
[17:29:03.705]             length <- base::length
[17:29:03.705]             list <- base::list
[17:29:03.705]             seq.int <- base::seq.int
[17:29:03.705]             signalCondition <- base::signalCondition
[17:29:03.705]             sys.calls <- base::sys.calls
[17:29:03.705]             `[[` <- base::`[[`
[17:29:03.705]             `+` <- base::`+`
[17:29:03.705]             `<<-` <- base::`<<-`
[17:29:03.705]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:03.705]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:03.705]                   3L)]
[17:29:03.705]             }
[17:29:03.705]             function(cond) {
[17:29:03.705]                 is_error <- inherits(cond, "error")
[17:29:03.705]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:03.705]                   NULL)
[17:29:03.705]                 if (is_error) {
[17:29:03.705]                   sessionInformation <- function() {
[17:29:03.705]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:03.705]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:03.705]                       search = base::search(), system = base::Sys.info())
[17:29:03.705]                   }
[17:29:03.705]                   ...future.conditions[[length(...future.conditions) + 
[17:29:03.705]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:03.705]                     cond$call), session = sessionInformation(), 
[17:29:03.705]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:03.705]                   signalCondition(cond)
[17:29:03.705]                 }
[17:29:03.705]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:03.705]                 "immediateCondition"))) {
[17:29:03.705]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:03.705]                   ...future.conditions[[length(...future.conditions) + 
[17:29:03.705]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:03.705]                   if (TRUE && !signal) {
[17:29:03.705]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:03.705]                     {
[17:29:03.705]                       inherits <- base::inherits
[17:29:03.705]                       invokeRestart <- base::invokeRestart
[17:29:03.705]                       is.null <- base::is.null
[17:29:03.705]                       muffled <- FALSE
[17:29:03.705]                       if (inherits(cond, "message")) {
[17:29:03.705]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:03.705]                         if (muffled) 
[17:29:03.705]                           invokeRestart("muffleMessage")
[17:29:03.705]                       }
[17:29:03.705]                       else if (inherits(cond, "warning")) {
[17:29:03.705]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:03.705]                         if (muffled) 
[17:29:03.705]                           invokeRestart("muffleWarning")
[17:29:03.705]                       }
[17:29:03.705]                       else if (inherits(cond, "condition")) {
[17:29:03.705]                         if (!is.null(pattern)) {
[17:29:03.705]                           computeRestarts <- base::computeRestarts
[17:29:03.705]                           grepl <- base::grepl
[17:29:03.705]                           restarts <- computeRestarts(cond)
[17:29:03.705]                           for (restart in restarts) {
[17:29:03.705]                             name <- restart$name
[17:29:03.705]                             if (is.null(name)) 
[17:29:03.705]                               next
[17:29:03.705]                             if (!grepl(pattern, name)) 
[17:29:03.705]                               next
[17:29:03.705]                             invokeRestart(restart)
[17:29:03.705]                             muffled <- TRUE
[17:29:03.705]                             break
[17:29:03.705]                           }
[17:29:03.705]                         }
[17:29:03.705]                       }
[17:29:03.705]                       invisible(muffled)
[17:29:03.705]                     }
[17:29:03.705]                     muffleCondition(cond, pattern = "^muffle")
[17:29:03.705]                   }
[17:29:03.705]                 }
[17:29:03.705]                 else {
[17:29:03.705]                   if (TRUE) {
[17:29:03.705]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:03.705]                     {
[17:29:03.705]                       inherits <- base::inherits
[17:29:03.705]                       invokeRestart <- base::invokeRestart
[17:29:03.705]                       is.null <- base::is.null
[17:29:03.705]                       muffled <- FALSE
[17:29:03.705]                       if (inherits(cond, "message")) {
[17:29:03.705]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:03.705]                         if (muffled) 
[17:29:03.705]                           invokeRestart("muffleMessage")
[17:29:03.705]                       }
[17:29:03.705]                       else if (inherits(cond, "warning")) {
[17:29:03.705]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:03.705]                         if (muffled) 
[17:29:03.705]                           invokeRestart("muffleWarning")
[17:29:03.705]                       }
[17:29:03.705]                       else if (inherits(cond, "condition")) {
[17:29:03.705]                         if (!is.null(pattern)) {
[17:29:03.705]                           computeRestarts <- base::computeRestarts
[17:29:03.705]                           grepl <- base::grepl
[17:29:03.705]                           restarts <- computeRestarts(cond)
[17:29:03.705]                           for (restart in restarts) {
[17:29:03.705]                             name <- restart$name
[17:29:03.705]                             if (is.null(name)) 
[17:29:03.705]                               next
[17:29:03.705]                             if (!grepl(pattern, name)) 
[17:29:03.705]                               next
[17:29:03.705]                             invokeRestart(restart)
[17:29:03.705]                             muffled <- TRUE
[17:29:03.705]                             break
[17:29:03.705]                           }
[17:29:03.705]                         }
[17:29:03.705]                       }
[17:29:03.705]                       invisible(muffled)
[17:29:03.705]                     }
[17:29:03.705]                     muffleCondition(cond, pattern = "^muffle")
[17:29:03.705]                   }
[17:29:03.705]                 }
[17:29:03.705]             }
[17:29:03.705]         }))
[17:29:03.705]     }, error = function(ex) {
[17:29:03.705]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:03.705]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:03.705]                 ...future.rng), started = ...future.startTime, 
[17:29:03.705]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:03.705]             version = "1.8"), class = "FutureResult")
[17:29:03.705]     }, finally = {
[17:29:03.705]         if (!identical(...future.workdir, getwd())) 
[17:29:03.705]             setwd(...future.workdir)
[17:29:03.705]         {
[17:29:03.705]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:03.705]                 ...future.oldOptions$nwarnings <- NULL
[17:29:03.705]             }
[17:29:03.705]             base::options(...future.oldOptions)
[17:29:03.705]             if (.Platform$OS.type == "windows") {
[17:29:03.705]                 old_names <- names(...future.oldEnvVars)
[17:29:03.705]                 envs <- base::Sys.getenv()
[17:29:03.705]                 names <- names(envs)
[17:29:03.705]                 common <- intersect(names, old_names)
[17:29:03.705]                 added <- setdiff(names, old_names)
[17:29:03.705]                 removed <- setdiff(old_names, names)
[17:29:03.705]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:03.705]                   envs[common]]
[17:29:03.705]                 NAMES <- toupper(changed)
[17:29:03.705]                 args <- list()
[17:29:03.705]                 for (kk in seq_along(NAMES)) {
[17:29:03.705]                   name <- changed[[kk]]
[17:29:03.705]                   NAME <- NAMES[[kk]]
[17:29:03.705]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:03.705]                     next
[17:29:03.705]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:03.705]                 }
[17:29:03.705]                 NAMES <- toupper(added)
[17:29:03.705]                 for (kk in seq_along(NAMES)) {
[17:29:03.705]                   name <- added[[kk]]
[17:29:03.705]                   NAME <- NAMES[[kk]]
[17:29:03.705]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:03.705]                     next
[17:29:03.705]                   args[[name]] <- ""
[17:29:03.705]                 }
[17:29:03.705]                 NAMES <- toupper(removed)
[17:29:03.705]                 for (kk in seq_along(NAMES)) {
[17:29:03.705]                   name <- removed[[kk]]
[17:29:03.705]                   NAME <- NAMES[[kk]]
[17:29:03.705]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:03.705]                     next
[17:29:03.705]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:03.705]                 }
[17:29:03.705]                 if (length(args) > 0) 
[17:29:03.705]                   base::do.call(base::Sys.setenv, args = args)
[17:29:03.705]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:03.705]             }
[17:29:03.705]             else {
[17:29:03.705]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:03.705]             }
[17:29:03.705]             {
[17:29:03.705]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:03.705]                   0L) {
[17:29:03.705]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:03.705]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:03.705]                   base::options(opts)
[17:29:03.705]                 }
[17:29:03.705]                 {
[17:29:03.705]                   {
[17:29:03.705]                     NULL
[17:29:03.705]                     RNGkind("Mersenne-Twister")
[17:29:03.705]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:03.705]                       inherits = FALSE)
[17:29:03.705]                   }
[17:29:03.705]                   options(future.plan = NULL)
[17:29:03.705]                   if (is.na(NA_character_)) 
[17:29:03.705]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:03.705]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:03.705]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:03.705]                     .init = FALSE)
[17:29:03.705]                 }
[17:29:03.705]             }
[17:29:03.705]         }
[17:29:03.705]     })
[17:29:03.705]     if (TRUE) {
[17:29:03.705]         base::sink(type = "output", split = FALSE)
[17:29:03.705]         if (TRUE) {
[17:29:03.705]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:03.705]         }
[17:29:03.705]         else {
[17:29:03.705]             ...future.result["stdout"] <- base::list(NULL)
[17:29:03.705]         }
[17:29:03.705]         base::close(...future.stdout)
[17:29:03.705]         ...future.stdout <- NULL
[17:29:03.705]     }
[17:29:03.705]     ...future.result$conditions <- ...future.conditions
[17:29:03.705]     ...future.result$finished <- base::Sys.time()
[17:29:03.705]     ...future.result
[17:29:03.705] }
[17:29:03.712] plan(): Setting new future strategy stack:
[17:29:03.712] List of future strategies:
[17:29:03.712] 1. sequential:
[17:29:03.712]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:03.712]    - tweaked: FALSE
[17:29:03.712]    - call: NULL
[17:29:03.713] plan(): nbrOfWorkers() = 1
[17:29:03.716] plan(): Setting new future strategy stack:
[17:29:03.716] List of future strategies:
[17:29:03.716] 1. sequential:
[17:29:03.716]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:03.716]    - tweaked: FALSE
[17:29:03.716]    - call: plan(strategy)
[17:29:03.717] plan(): nbrOfWorkers() = 1
[17:29:03.717] SequentialFuture started (and completed)
[17:29:03.718] - Launch lazy future ... done
[17:29:03.719] run() for 'SequentialFuture' ... done
[17:29:03.719] getGlobalsAndPackages() ...
[17:29:03.719] Searching for globals...
[17:29:03.720] 
[17:29:03.720] Searching for globals ... DONE
[17:29:03.720] - globals: [0] <none>
[17:29:03.720] getGlobalsAndPackages() ... DONE
[17:29:03.721] run() for 'Future' ...
[17:29:03.721] - state: 'created'
[17:29:03.722] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:03.722] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:03.722] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:03.723]   - Field: 'label'
[17:29:03.723]   - Field: 'local'
[17:29:03.723]   - Field: 'owner'
[17:29:03.724]   - Field: 'envir'
[17:29:03.724]   - Field: 'packages'
[17:29:03.724]   - Field: 'gc'
[17:29:03.724]   - Field: 'conditions'
[17:29:03.725]   - Field: 'expr'
[17:29:03.725]   - Field: 'uuid'
[17:29:03.728]   - Field: 'seed'
[17:29:03.729]   - Field: 'version'
[17:29:03.729]   - Field: 'result'
[17:29:03.729]   - Field: 'asynchronous'
[17:29:03.729]   - Field: 'calls'
[17:29:03.730]   - Field: 'globals'
[17:29:03.730]   - Field: 'stdout'
[17:29:03.730]   - Field: 'earlySignal'
[17:29:03.730]   - Field: 'lazy'
[17:29:03.731]   - Field: 'state'
[17:29:03.731] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:03.731] - Launch lazy future ...
[17:29:03.732] Packages needed by the future expression (n = 0): <none>
[17:29:03.732] Packages needed by future strategies (n = 0): <none>
[17:29:03.733] {
[17:29:03.733]     {
[17:29:03.733]         {
[17:29:03.733]             ...future.startTime <- base::Sys.time()
[17:29:03.733]             {
[17:29:03.733]                 {
[17:29:03.733]                   {
[17:29:03.733]                     base::local({
[17:29:03.733]                       has_future <- base::requireNamespace("future", 
[17:29:03.733]                         quietly = TRUE)
[17:29:03.733]                       if (has_future) {
[17:29:03.733]                         ns <- base::getNamespace("future")
[17:29:03.733]                         version <- ns[[".package"]][["version"]]
[17:29:03.733]                         if (is.null(version)) 
[17:29:03.733]                           version <- utils::packageVersion("future")
[17:29:03.733]                       }
[17:29:03.733]                       else {
[17:29:03.733]                         version <- NULL
[17:29:03.733]                       }
[17:29:03.733]                       if (!has_future || version < "1.8.0") {
[17:29:03.733]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:03.733]                           "", base::R.version$version.string), 
[17:29:03.733]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:03.733]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:03.733]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:03.733]                             "release", "version")], collapse = " "), 
[17:29:03.733]                           hostname = base::Sys.info()[["nodename"]])
[17:29:03.733]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:03.733]                           info)
[17:29:03.733]                         info <- base::paste(info, collapse = "; ")
[17:29:03.733]                         if (!has_future) {
[17:29:03.733]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:03.733]                             info)
[17:29:03.733]                         }
[17:29:03.733]                         else {
[17:29:03.733]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:03.733]                             info, version)
[17:29:03.733]                         }
[17:29:03.733]                         base::stop(msg)
[17:29:03.733]                       }
[17:29:03.733]                     })
[17:29:03.733]                   }
[17:29:03.733]                   ...future.strategy.old <- future::plan("list")
[17:29:03.733]                   options(future.plan = NULL)
[17:29:03.733]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:03.733]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:03.733]                 }
[17:29:03.733]                 ...future.workdir <- getwd()
[17:29:03.733]             }
[17:29:03.733]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:03.733]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:03.733]         }
[17:29:03.733]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:03.733]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:03.733]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:03.733]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:03.733]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:03.733]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:03.733]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:03.733]             base::names(...future.oldOptions))
[17:29:03.733]     }
[17:29:03.733]     if (FALSE) {
[17:29:03.733]     }
[17:29:03.733]     else {
[17:29:03.733]         if (TRUE) {
[17:29:03.733]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:03.733]                 open = "w")
[17:29:03.733]         }
[17:29:03.733]         else {
[17:29:03.733]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:03.733]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:03.733]         }
[17:29:03.733]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:03.733]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:03.733]             base::sink(type = "output", split = FALSE)
[17:29:03.733]             base::close(...future.stdout)
[17:29:03.733]         }, add = TRUE)
[17:29:03.733]     }
[17:29:03.733]     ...future.frame <- base::sys.nframe()
[17:29:03.733]     ...future.conditions <- base::list()
[17:29:03.733]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:03.733]     if (FALSE) {
[17:29:03.733]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:03.733]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:03.733]     }
[17:29:03.733]     ...future.result <- base::tryCatch({
[17:29:03.733]         base::withCallingHandlers({
[17:29:03.733]             ...future.value <- base::withVisible(base::local(2))
[17:29:03.733]             future::FutureResult(value = ...future.value$value, 
[17:29:03.733]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:03.733]                   ...future.rng), globalenv = if (FALSE) 
[17:29:03.733]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:03.733]                     ...future.globalenv.names))
[17:29:03.733]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:03.733]         }, condition = base::local({
[17:29:03.733]             c <- base::c
[17:29:03.733]             inherits <- base::inherits
[17:29:03.733]             invokeRestart <- base::invokeRestart
[17:29:03.733]             length <- base::length
[17:29:03.733]             list <- base::list
[17:29:03.733]             seq.int <- base::seq.int
[17:29:03.733]             signalCondition <- base::signalCondition
[17:29:03.733]             sys.calls <- base::sys.calls
[17:29:03.733]             `[[` <- base::`[[`
[17:29:03.733]             `+` <- base::`+`
[17:29:03.733]             `<<-` <- base::`<<-`
[17:29:03.733]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:03.733]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:03.733]                   3L)]
[17:29:03.733]             }
[17:29:03.733]             function(cond) {
[17:29:03.733]                 is_error <- inherits(cond, "error")
[17:29:03.733]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:03.733]                   NULL)
[17:29:03.733]                 if (is_error) {
[17:29:03.733]                   sessionInformation <- function() {
[17:29:03.733]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:03.733]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:03.733]                       search = base::search(), system = base::Sys.info())
[17:29:03.733]                   }
[17:29:03.733]                   ...future.conditions[[length(...future.conditions) + 
[17:29:03.733]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:03.733]                     cond$call), session = sessionInformation(), 
[17:29:03.733]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:03.733]                   signalCondition(cond)
[17:29:03.733]                 }
[17:29:03.733]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:03.733]                 "immediateCondition"))) {
[17:29:03.733]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:03.733]                   ...future.conditions[[length(...future.conditions) + 
[17:29:03.733]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:03.733]                   if (TRUE && !signal) {
[17:29:03.733]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:03.733]                     {
[17:29:03.733]                       inherits <- base::inherits
[17:29:03.733]                       invokeRestart <- base::invokeRestart
[17:29:03.733]                       is.null <- base::is.null
[17:29:03.733]                       muffled <- FALSE
[17:29:03.733]                       if (inherits(cond, "message")) {
[17:29:03.733]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:03.733]                         if (muffled) 
[17:29:03.733]                           invokeRestart("muffleMessage")
[17:29:03.733]                       }
[17:29:03.733]                       else if (inherits(cond, "warning")) {
[17:29:03.733]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:03.733]                         if (muffled) 
[17:29:03.733]                           invokeRestart("muffleWarning")
[17:29:03.733]                       }
[17:29:03.733]                       else if (inherits(cond, "condition")) {
[17:29:03.733]                         if (!is.null(pattern)) {
[17:29:03.733]                           computeRestarts <- base::computeRestarts
[17:29:03.733]                           grepl <- base::grepl
[17:29:03.733]                           restarts <- computeRestarts(cond)
[17:29:03.733]                           for (restart in restarts) {
[17:29:03.733]                             name <- restart$name
[17:29:03.733]                             if (is.null(name)) 
[17:29:03.733]                               next
[17:29:03.733]                             if (!grepl(pattern, name)) 
[17:29:03.733]                               next
[17:29:03.733]                             invokeRestart(restart)
[17:29:03.733]                             muffled <- TRUE
[17:29:03.733]                             break
[17:29:03.733]                           }
[17:29:03.733]                         }
[17:29:03.733]                       }
[17:29:03.733]                       invisible(muffled)
[17:29:03.733]                     }
[17:29:03.733]                     muffleCondition(cond, pattern = "^muffle")
[17:29:03.733]                   }
[17:29:03.733]                 }
[17:29:03.733]                 else {
[17:29:03.733]                   if (TRUE) {
[17:29:03.733]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:03.733]                     {
[17:29:03.733]                       inherits <- base::inherits
[17:29:03.733]                       invokeRestart <- base::invokeRestart
[17:29:03.733]                       is.null <- base::is.null
[17:29:03.733]                       muffled <- FALSE
[17:29:03.733]                       if (inherits(cond, "message")) {
[17:29:03.733]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:03.733]                         if (muffled) 
[17:29:03.733]                           invokeRestart("muffleMessage")
[17:29:03.733]                       }
[17:29:03.733]                       else if (inherits(cond, "warning")) {
[17:29:03.733]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:03.733]                         if (muffled) 
[17:29:03.733]                           invokeRestart("muffleWarning")
[17:29:03.733]                       }
[17:29:03.733]                       else if (inherits(cond, "condition")) {
[17:29:03.733]                         if (!is.null(pattern)) {
[17:29:03.733]                           computeRestarts <- base::computeRestarts
[17:29:03.733]                           grepl <- base::grepl
[17:29:03.733]                           restarts <- computeRestarts(cond)
[17:29:03.733]                           for (restart in restarts) {
[17:29:03.733]                             name <- restart$name
[17:29:03.733]                             if (is.null(name)) 
[17:29:03.733]                               next
[17:29:03.733]                             if (!grepl(pattern, name)) 
[17:29:03.733]                               next
[17:29:03.733]                             invokeRestart(restart)
[17:29:03.733]                             muffled <- TRUE
[17:29:03.733]                             break
[17:29:03.733]                           }
[17:29:03.733]                         }
[17:29:03.733]                       }
[17:29:03.733]                       invisible(muffled)
[17:29:03.733]                     }
[17:29:03.733]                     muffleCondition(cond, pattern = "^muffle")
[17:29:03.733]                   }
[17:29:03.733]                 }
[17:29:03.733]             }
[17:29:03.733]         }))
[17:29:03.733]     }, error = function(ex) {
[17:29:03.733]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:03.733]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:03.733]                 ...future.rng), started = ...future.startTime, 
[17:29:03.733]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:03.733]             version = "1.8"), class = "FutureResult")
[17:29:03.733]     }, finally = {
[17:29:03.733]         if (!identical(...future.workdir, getwd())) 
[17:29:03.733]             setwd(...future.workdir)
[17:29:03.733]         {
[17:29:03.733]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:03.733]                 ...future.oldOptions$nwarnings <- NULL
[17:29:03.733]             }
[17:29:03.733]             base::options(...future.oldOptions)
[17:29:03.733]             if (.Platform$OS.type == "windows") {
[17:29:03.733]                 old_names <- names(...future.oldEnvVars)
[17:29:03.733]                 envs <- base::Sys.getenv()
[17:29:03.733]                 names <- names(envs)
[17:29:03.733]                 common <- intersect(names, old_names)
[17:29:03.733]                 added <- setdiff(names, old_names)
[17:29:03.733]                 removed <- setdiff(old_names, names)
[17:29:03.733]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:03.733]                   envs[common]]
[17:29:03.733]                 NAMES <- toupper(changed)
[17:29:03.733]                 args <- list()
[17:29:03.733]                 for (kk in seq_along(NAMES)) {
[17:29:03.733]                   name <- changed[[kk]]
[17:29:03.733]                   NAME <- NAMES[[kk]]
[17:29:03.733]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:03.733]                     next
[17:29:03.733]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:03.733]                 }
[17:29:03.733]                 NAMES <- toupper(added)
[17:29:03.733]                 for (kk in seq_along(NAMES)) {
[17:29:03.733]                   name <- added[[kk]]
[17:29:03.733]                   NAME <- NAMES[[kk]]
[17:29:03.733]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:03.733]                     next
[17:29:03.733]                   args[[name]] <- ""
[17:29:03.733]                 }
[17:29:03.733]                 NAMES <- toupper(removed)
[17:29:03.733]                 for (kk in seq_along(NAMES)) {
[17:29:03.733]                   name <- removed[[kk]]
[17:29:03.733]                   NAME <- NAMES[[kk]]
[17:29:03.733]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:03.733]                     next
[17:29:03.733]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:03.733]                 }
[17:29:03.733]                 if (length(args) > 0) 
[17:29:03.733]                   base::do.call(base::Sys.setenv, args = args)
[17:29:03.733]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:03.733]             }
[17:29:03.733]             else {
[17:29:03.733]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:03.733]             }
[17:29:03.733]             {
[17:29:03.733]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:03.733]                   0L) {
[17:29:03.733]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:03.733]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:03.733]                   base::options(opts)
[17:29:03.733]                 }
[17:29:03.733]                 {
[17:29:03.733]                   {
[17:29:03.733]                     NULL
[17:29:03.733]                     RNGkind("Mersenne-Twister")
[17:29:03.733]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:03.733]                       inherits = FALSE)
[17:29:03.733]                   }
[17:29:03.733]                   options(future.plan = NULL)
[17:29:03.733]                   if (is.na(NA_character_)) 
[17:29:03.733]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:03.733]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:03.733]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:03.733]                     .init = FALSE)
[17:29:03.733]                 }
[17:29:03.733]             }
[17:29:03.733]         }
[17:29:03.733]     })
[17:29:03.733]     if (TRUE) {
[17:29:03.733]         base::sink(type = "output", split = FALSE)
[17:29:03.733]         if (TRUE) {
[17:29:03.733]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:03.733]         }
[17:29:03.733]         else {
[17:29:03.733]             ...future.result["stdout"] <- base::list(NULL)
[17:29:03.733]         }
[17:29:03.733]         base::close(...future.stdout)
[17:29:03.733]         ...future.stdout <- NULL
[17:29:03.733]     }
[17:29:03.733]     ...future.result$conditions <- ...future.conditions
[17:29:03.733]     ...future.result$finished <- base::Sys.time()
[17:29:03.733]     ...future.result
[17:29:03.733] }
[17:29:03.738] plan(): Setting new future strategy stack:
[17:29:03.738] List of future strategies:
[17:29:03.738] 1. sequential:
[17:29:03.738]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:03.738]    - tweaked: FALSE
[17:29:03.738]    - call: NULL
[17:29:03.739] plan(): nbrOfWorkers() = 1
[17:29:03.740] plan(): Setting new future strategy stack:
[17:29:03.740] List of future strategies:
[17:29:03.740] 1. sequential:
[17:29:03.740]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:03.740]    - tweaked: FALSE
[17:29:03.740]    - call: plan(strategy)
[17:29:03.741] plan(): nbrOfWorkers() = 1
[17:29:03.741] SequentialFuture started (and completed)
[17:29:03.741] - Launch lazy future ... done
[17:29:03.742] run() for 'SequentialFuture' ... done
[17:29:03.742] resolve() on list ...
[17:29:03.742]  recursive: 0
[17:29:03.742]  length: 3
[17:29:03.742]  elements: 'a', 'b', ''
[17:29:03.743] resolved() for 'SequentialFuture' ...
[17:29:03.743] - state: 'finished'
[17:29:03.743] - run: TRUE
[17:29:03.743] - result: 'FutureResult'
[17:29:03.743] resolved() for 'SequentialFuture' ... done
[17:29:03.744] Future #1
[17:29:03.744]  length: 2 (resolved future 1)
[17:29:03.744] resolved() for 'SequentialFuture' ...
[17:29:03.744] - state: 'finished'
[17:29:03.745] - run: TRUE
[17:29:03.745] - result: 'FutureResult'
[17:29:03.745] resolved() for 'SequentialFuture' ... done
[17:29:03.745] Future #2
[17:29:03.745]  length: 1 (resolved future 2)
[17:29:03.746]  length: 0 (resolved future 3)
[17:29:03.746] resolve() on list ... DONE
[17:29:03.746] resolved() for 'SequentialFuture' ...
[17:29:03.746] - state: 'finished'
[17:29:03.746] - run: TRUE
[17:29:03.747] - result: 'FutureResult'
[17:29:03.747] resolved() for 'SequentialFuture' ... done
[17:29:03.747] resolved() for 'SequentialFuture' ...
[17:29:03.748] - state: 'finished'
[17:29:03.748] - run: TRUE
[17:29:03.748] - result: 'FutureResult'
[17:29:03.748] resolved() for 'SequentialFuture' ... done
[17:29:03.749] getGlobalsAndPackages() ...
[17:29:03.749] Searching for globals...
[17:29:03.749] 
[17:29:03.750] Searching for globals ... DONE
[17:29:03.750] - globals: [0] <none>
[17:29:03.750] getGlobalsAndPackages() ... DONE
[17:29:03.750] getGlobalsAndPackages() ...
[17:29:03.750] Searching for globals...
[17:29:03.751] 
[17:29:03.751] Searching for globals ... DONE
[17:29:03.751] - globals: [0] <none>
[17:29:03.751] getGlobalsAndPackages() ... DONE
[17:29:03.752] run() for 'Future' ...
[17:29:03.752] - state: 'created'
[17:29:03.752] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:03.753] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:03.753] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:03.753]   - Field: 'label'
[17:29:03.753]   - Field: 'local'
[17:29:03.754]   - Field: 'owner'
[17:29:03.754]   - Field: 'envir'
[17:29:03.754]   - Field: 'packages'
[17:29:03.754]   - Field: 'gc'
[17:29:03.754]   - Field: 'conditions'
[17:29:03.755]   - Field: 'expr'
[17:29:03.755]   - Field: 'uuid'
[17:29:03.755]   - Field: 'seed'
[17:29:03.755]   - Field: 'version'
[17:29:03.755]   - Field: 'result'
[17:29:03.756]   - Field: 'asynchronous'
[17:29:03.756]   - Field: 'calls'
[17:29:03.756]   - Field: 'globals'
[17:29:03.756]   - Field: 'stdout'
[17:29:03.756]   - Field: 'earlySignal'
[17:29:03.756]   - Field: 'lazy'
[17:29:03.757]   - Field: 'state'
[17:29:03.757] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:03.757] - Launch lazy future ...
[17:29:03.757] Packages needed by the future expression (n = 0): <none>
[17:29:03.757] Packages needed by future strategies (n = 0): <none>
[17:29:03.758] {
[17:29:03.758]     {
[17:29:03.758]         {
[17:29:03.758]             ...future.startTime <- base::Sys.time()
[17:29:03.758]             {
[17:29:03.758]                 {
[17:29:03.758]                   {
[17:29:03.758]                     base::local({
[17:29:03.758]                       has_future <- base::requireNamespace("future", 
[17:29:03.758]                         quietly = TRUE)
[17:29:03.758]                       if (has_future) {
[17:29:03.758]                         ns <- base::getNamespace("future")
[17:29:03.758]                         version <- ns[[".package"]][["version"]]
[17:29:03.758]                         if (is.null(version)) 
[17:29:03.758]                           version <- utils::packageVersion("future")
[17:29:03.758]                       }
[17:29:03.758]                       else {
[17:29:03.758]                         version <- NULL
[17:29:03.758]                       }
[17:29:03.758]                       if (!has_future || version < "1.8.0") {
[17:29:03.758]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:03.758]                           "", base::R.version$version.string), 
[17:29:03.758]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:03.758]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:03.758]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:03.758]                             "release", "version")], collapse = " "), 
[17:29:03.758]                           hostname = base::Sys.info()[["nodename"]])
[17:29:03.758]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:03.758]                           info)
[17:29:03.758]                         info <- base::paste(info, collapse = "; ")
[17:29:03.758]                         if (!has_future) {
[17:29:03.758]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:03.758]                             info)
[17:29:03.758]                         }
[17:29:03.758]                         else {
[17:29:03.758]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:03.758]                             info, version)
[17:29:03.758]                         }
[17:29:03.758]                         base::stop(msg)
[17:29:03.758]                       }
[17:29:03.758]                     })
[17:29:03.758]                   }
[17:29:03.758]                   ...future.strategy.old <- future::plan("list")
[17:29:03.758]                   options(future.plan = NULL)
[17:29:03.758]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:03.758]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:03.758]                 }
[17:29:03.758]                 ...future.workdir <- getwd()
[17:29:03.758]             }
[17:29:03.758]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:03.758]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:03.758]         }
[17:29:03.758]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:03.758]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:03.758]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:03.758]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:03.758]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:03.758]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:03.758]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:03.758]             base::names(...future.oldOptions))
[17:29:03.758]     }
[17:29:03.758]     if (FALSE) {
[17:29:03.758]     }
[17:29:03.758]     else {
[17:29:03.758]         if (TRUE) {
[17:29:03.758]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:03.758]                 open = "w")
[17:29:03.758]         }
[17:29:03.758]         else {
[17:29:03.758]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:03.758]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:03.758]         }
[17:29:03.758]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:03.758]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:03.758]             base::sink(type = "output", split = FALSE)
[17:29:03.758]             base::close(...future.stdout)
[17:29:03.758]         }, add = TRUE)
[17:29:03.758]     }
[17:29:03.758]     ...future.frame <- base::sys.nframe()
[17:29:03.758]     ...future.conditions <- base::list()
[17:29:03.758]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:03.758]     if (FALSE) {
[17:29:03.758]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:03.758]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:03.758]     }
[17:29:03.758]     ...future.result <- base::tryCatch({
[17:29:03.758]         base::withCallingHandlers({
[17:29:03.758]             ...future.value <- base::withVisible(base::local(2))
[17:29:03.758]             future::FutureResult(value = ...future.value$value, 
[17:29:03.758]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:03.758]                   ...future.rng), globalenv = if (FALSE) 
[17:29:03.758]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:03.758]                     ...future.globalenv.names))
[17:29:03.758]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:03.758]         }, condition = base::local({
[17:29:03.758]             c <- base::c
[17:29:03.758]             inherits <- base::inherits
[17:29:03.758]             invokeRestart <- base::invokeRestart
[17:29:03.758]             length <- base::length
[17:29:03.758]             list <- base::list
[17:29:03.758]             seq.int <- base::seq.int
[17:29:03.758]             signalCondition <- base::signalCondition
[17:29:03.758]             sys.calls <- base::sys.calls
[17:29:03.758]             `[[` <- base::`[[`
[17:29:03.758]             `+` <- base::`+`
[17:29:03.758]             `<<-` <- base::`<<-`
[17:29:03.758]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:03.758]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:03.758]                   3L)]
[17:29:03.758]             }
[17:29:03.758]             function(cond) {
[17:29:03.758]                 is_error <- inherits(cond, "error")
[17:29:03.758]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:03.758]                   NULL)
[17:29:03.758]                 if (is_error) {
[17:29:03.758]                   sessionInformation <- function() {
[17:29:03.758]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:03.758]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:03.758]                       search = base::search(), system = base::Sys.info())
[17:29:03.758]                   }
[17:29:03.758]                   ...future.conditions[[length(...future.conditions) + 
[17:29:03.758]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:03.758]                     cond$call), session = sessionInformation(), 
[17:29:03.758]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:03.758]                   signalCondition(cond)
[17:29:03.758]                 }
[17:29:03.758]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:03.758]                 "immediateCondition"))) {
[17:29:03.758]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:03.758]                   ...future.conditions[[length(...future.conditions) + 
[17:29:03.758]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:03.758]                   if (TRUE && !signal) {
[17:29:03.758]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:03.758]                     {
[17:29:03.758]                       inherits <- base::inherits
[17:29:03.758]                       invokeRestart <- base::invokeRestart
[17:29:03.758]                       is.null <- base::is.null
[17:29:03.758]                       muffled <- FALSE
[17:29:03.758]                       if (inherits(cond, "message")) {
[17:29:03.758]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:03.758]                         if (muffled) 
[17:29:03.758]                           invokeRestart("muffleMessage")
[17:29:03.758]                       }
[17:29:03.758]                       else if (inherits(cond, "warning")) {
[17:29:03.758]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:03.758]                         if (muffled) 
[17:29:03.758]                           invokeRestart("muffleWarning")
[17:29:03.758]                       }
[17:29:03.758]                       else if (inherits(cond, "condition")) {
[17:29:03.758]                         if (!is.null(pattern)) {
[17:29:03.758]                           computeRestarts <- base::computeRestarts
[17:29:03.758]                           grepl <- base::grepl
[17:29:03.758]                           restarts <- computeRestarts(cond)
[17:29:03.758]                           for (restart in restarts) {
[17:29:03.758]                             name <- restart$name
[17:29:03.758]                             if (is.null(name)) 
[17:29:03.758]                               next
[17:29:03.758]                             if (!grepl(pattern, name)) 
[17:29:03.758]                               next
[17:29:03.758]                             invokeRestart(restart)
[17:29:03.758]                             muffled <- TRUE
[17:29:03.758]                             break
[17:29:03.758]                           }
[17:29:03.758]                         }
[17:29:03.758]                       }
[17:29:03.758]                       invisible(muffled)
[17:29:03.758]                     }
[17:29:03.758]                     muffleCondition(cond, pattern = "^muffle")
[17:29:03.758]                   }
[17:29:03.758]                 }
[17:29:03.758]                 else {
[17:29:03.758]                   if (TRUE) {
[17:29:03.758]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:03.758]                     {
[17:29:03.758]                       inherits <- base::inherits
[17:29:03.758]                       invokeRestart <- base::invokeRestart
[17:29:03.758]                       is.null <- base::is.null
[17:29:03.758]                       muffled <- FALSE
[17:29:03.758]                       if (inherits(cond, "message")) {
[17:29:03.758]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:03.758]                         if (muffled) 
[17:29:03.758]                           invokeRestart("muffleMessage")
[17:29:03.758]                       }
[17:29:03.758]                       else if (inherits(cond, "warning")) {
[17:29:03.758]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:03.758]                         if (muffled) 
[17:29:03.758]                           invokeRestart("muffleWarning")
[17:29:03.758]                       }
[17:29:03.758]                       else if (inherits(cond, "condition")) {
[17:29:03.758]                         if (!is.null(pattern)) {
[17:29:03.758]                           computeRestarts <- base::computeRestarts
[17:29:03.758]                           grepl <- base::grepl
[17:29:03.758]                           restarts <- computeRestarts(cond)
[17:29:03.758]                           for (restart in restarts) {
[17:29:03.758]                             name <- restart$name
[17:29:03.758]                             if (is.null(name)) 
[17:29:03.758]                               next
[17:29:03.758]                             if (!grepl(pattern, name)) 
[17:29:03.758]                               next
[17:29:03.758]                             invokeRestart(restart)
[17:29:03.758]                             muffled <- TRUE
[17:29:03.758]                             break
[17:29:03.758]                           }
[17:29:03.758]                         }
[17:29:03.758]                       }
[17:29:03.758]                       invisible(muffled)
[17:29:03.758]                     }
[17:29:03.758]                     muffleCondition(cond, pattern = "^muffle")
[17:29:03.758]                   }
[17:29:03.758]                 }
[17:29:03.758]             }
[17:29:03.758]         }))
[17:29:03.758]     }, error = function(ex) {
[17:29:03.758]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:03.758]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:03.758]                 ...future.rng), started = ...future.startTime, 
[17:29:03.758]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:03.758]             version = "1.8"), class = "FutureResult")
[17:29:03.758]     }, finally = {
[17:29:03.758]         if (!identical(...future.workdir, getwd())) 
[17:29:03.758]             setwd(...future.workdir)
[17:29:03.758]         {
[17:29:03.758]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:03.758]                 ...future.oldOptions$nwarnings <- NULL
[17:29:03.758]             }
[17:29:03.758]             base::options(...future.oldOptions)
[17:29:03.758]             if (.Platform$OS.type == "windows") {
[17:29:03.758]                 old_names <- names(...future.oldEnvVars)
[17:29:03.758]                 envs <- base::Sys.getenv()
[17:29:03.758]                 names <- names(envs)
[17:29:03.758]                 common <- intersect(names, old_names)
[17:29:03.758]                 added <- setdiff(names, old_names)
[17:29:03.758]                 removed <- setdiff(old_names, names)
[17:29:03.758]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:03.758]                   envs[common]]
[17:29:03.758]                 NAMES <- toupper(changed)
[17:29:03.758]                 args <- list()
[17:29:03.758]                 for (kk in seq_along(NAMES)) {
[17:29:03.758]                   name <- changed[[kk]]
[17:29:03.758]                   NAME <- NAMES[[kk]]
[17:29:03.758]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:03.758]                     next
[17:29:03.758]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:03.758]                 }
[17:29:03.758]                 NAMES <- toupper(added)
[17:29:03.758]                 for (kk in seq_along(NAMES)) {
[17:29:03.758]                   name <- added[[kk]]
[17:29:03.758]                   NAME <- NAMES[[kk]]
[17:29:03.758]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:03.758]                     next
[17:29:03.758]                   args[[name]] <- ""
[17:29:03.758]                 }
[17:29:03.758]                 NAMES <- toupper(removed)
[17:29:03.758]                 for (kk in seq_along(NAMES)) {
[17:29:03.758]                   name <- removed[[kk]]
[17:29:03.758]                   NAME <- NAMES[[kk]]
[17:29:03.758]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:03.758]                     next
[17:29:03.758]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:03.758]                 }
[17:29:03.758]                 if (length(args) > 0) 
[17:29:03.758]                   base::do.call(base::Sys.setenv, args = args)
[17:29:03.758]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:03.758]             }
[17:29:03.758]             else {
[17:29:03.758]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:03.758]             }
[17:29:03.758]             {
[17:29:03.758]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:03.758]                   0L) {
[17:29:03.758]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:03.758]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:03.758]                   base::options(opts)
[17:29:03.758]                 }
[17:29:03.758]                 {
[17:29:03.758]                   {
[17:29:03.758]                     NULL
[17:29:03.758]                     RNGkind("Mersenne-Twister")
[17:29:03.758]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:03.758]                       inherits = FALSE)
[17:29:03.758]                   }
[17:29:03.758]                   options(future.plan = NULL)
[17:29:03.758]                   if (is.na(NA_character_)) 
[17:29:03.758]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:03.758]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:03.758]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:03.758]                     .init = FALSE)
[17:29:03.758]                 }
[17:29:03.758]             }
[17:29:03.758]         }
[17:29:03.758]     })
[17:29:03.758]     if (TRUE) {
[17:29:03.758]         base::sink(type = "output", split = FALSE)
[17:29:03.758]         if (TRUE) {
[17:29:03.758]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:03.758]         }
[17:29:03.758]         else {
[17:29:03.758]             ...future.result["stdout"] <- base::list(NULL)
[17:29:03.758]         }
[17:29:03.758]         base::close(...future.stdout)
[17:29:03.758]         ...future.stdout <- NULL
[17:29:03.758]     }
[17:29:03.758]     ...future.result$conditions <- ...future.conditions
[17:29:03.758]     ...future.result$finished <- base::Sys.time()
[17:29:03.758]     ...future.result
[17:29:03.758] }
[17:29:03.762] plan(): Setting new future strategy stack:
[17:29:03.763] List of future strategies:
[17:29:03.763] 1. sequential:
[17:29:03.763]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:03.763]    - tweaked: FALSE
[17:29:03.763]    - call: NULL
[17:29:03.763] plan(): nbrOfWorkers() = 1
[17:29:03.765] plan(): Setting new future strategy stack:
[17:29:03.765] List of future strategies:
[17:29:03.765] 1. sequential:
[17:29:03.765]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:03.765]    - tweaked: FALSE
[17:29:03.765]    - call: plan(strategy)
[17:29:03.765] plan(): nbrOfWorkers() = 1
[17:29:03.766] SequentialFuture started (and completed)
[17:29:03.766] - Launch lazy future ... done
[17:29:03.766] run() for 'SequentialFuture' ... done
[17:29:03.766] resolve() on list ...
[17:29:03.767]  recursive: 0
[17:29:03.767]  length: 3
[17:29:03.767]  elements: 'a', 'b', ''
[17:29:03.767] run() for 'Future' ...
[17:29:03.767] - state: 'created'
[17:29:03.768] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:03.768] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:03.768] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:03.768]   - Field: 'label'
[17:29:03.769]   - Field: 'local'
[17:29:03.769]   - Field: 'owner'
[17:29:03.769]   - Field: 'envir'
[17:29:03.769]   - Field: 'packages'
[17:29:03.769]   - Field: 'gc'
[17:29:03.770]   - Field: 'conditions'
[17:29:03.770]   - Field: 'expr'
[17:29:03.770]   - Field: 'uuid'
[17:29:03.770]   - Field: 'seed'
[17:29:03.770]   - Field: 'version'
[17:29:03.770]   - Field: 'result'
[17:29:03.771]   - Field: 'asynchronous'
[17:29:03.771]   - Field: 'calls'
[17:29:03.771]   - Field: 'globals'
[17:29:03.771]   - Field: 'stdout'
[17:29:03.771]   - Field: 'earlySignal'
[17:29:03.772]   - Field: 'lazy'
[17:29:03.772]   - Field: 'state'
[17:29:03.772] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:03.772] - Launch lazy future ...
[17:29:03.772] Packages needed by the future expression (n = 0): <none>
[17:29:03.773] Packages needed by future strategies (n = 0): <none>
[17:29:03.773] {
[17:29:03.773]     {
[17:29:03.773]         {
[17:29:03.773]             ...future.startTime <- base::Sys.time()
[17:29:03.773]             {
[17:29:03.773]                 {
[17:29:03.773]                   {
[17:29:03.773]                     base::local({
[17:29:03.773]                       has_future <- base::requireNamespace("future", 
[17:29:03.773]                         quietly = TRUE)
[17:29:03.773]                       if (has_future) {
[17:29:03.773]                         ns <- base::getNamespace("future")
[17:29:03.773]                         version <- ns[[".package"]][["version"]]
[17:29:03.773]                         if (is.null(version)) 
[17:29:03.773]                           version <- utils::packageVersion("future")
[17:29:03.773]                       }
[17:29:03.773]                       else {
[17:29:03.773]                         version <- NULL
[17:29:03.773]                       }
[17:29:03.773]                       if (!has_future || version < "1.8.0") {
[17:29:03.773]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:03.773]                           "", base::R.version$version.string), 
[17:29:03.773]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:03.773]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:03.773]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:03.773]                             "release", "version")], collapse = " "), 
[17:29:03.773]                           hostname = base::Sys.info()[["nodename"]])
[17:29:03.773]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:03.773]                           info)
[17:29:03.773]                         info <- base::paste(info, collapse = "; ")
[17:29:03.773]                         if (!has_future) {
[17:29:03.773]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:03.773]                             info)
[17:29:03.773]                         }
[17:29:03.773]                         else {
[17:29:03.773]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:03.773]                             info, version)
[17:29:03.773]                         }
[17:29:03.773]                         base::stop(msg)
[17:29:03.773]                       }
[17:29:03.773]                     })
[17:29:03.773]                   }
[17:29:03.773]                   ...future.strategy.old <- future::plan("list")
[17:29:03.773]                   options(future.plan = NULL)
[17:29:03.773]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:03.773]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:03.773]                 }
[17:29:03.773]                 ...future.workdir <- getwd()
[17:29:03.773]             }
[17:29:03.773]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:03.773]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:03.773]         }
[17:29:03.773]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:03.773]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:03.773]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:03.773]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:03.773]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:03.773]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:03.773]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:03.773]             base::names(...future.oldOptions))
[17:29:03.773]     }
[17:29:03.773]     if (FALSE) {
[17:29:03.773]     }
[17:29:03.773]     else {
[17:29:03.773]         if (TRUE) {
[17:29:03.773]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:03.773]                 open = "w")
[17:29:03.773]         }
[17:29:03.773]         else {
[17:29:03.773]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:03.773]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:03.773]         }
[17:29:03.773]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:03.773]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:03.773]             base::sink(type = "output", split = FALSE)
[17:29:03.773]             base::close(...future.stdout)
[17:29:03.773]         }, add = TRUE)
[17:29:03.773]     }
[17:29:03.773]     ...future.frame <- base::sys.nframe()
[17:29:03.773]     ...future.conditions <- base::list()
[17:29:03.773]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:03.773]     if (FALSE) {
[17:29:03.773]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:03.773]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:03.773]     }
[17:29:03.773]     ...future.result <- base::tryCatch({
[17:29:03.773]         base::withCallingHandlers({
[17:29:03.773]             ...future.value <- base::withVisible(base::local(1))
[17:29:03.773]             future::FutureResult(value = ...future.value$value, 
[17:29:03.773]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:03.773]                   ...future.rng), globalenv = if (FALSE) 
[17:29:03.773]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:03.773]                     ...future.globalenv.names))
[17:29:03.773]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:03.773]         }, condition = base::local({
[17:29:03.773]             c <- base::c
[17:29:03.773]             inherits <- base::inherits
[17:29:03.773]             invokeRestart <- base::invokeRestart
[17:29:03.773]             length <- base::length
[17:29:03.773]             list <- base::list
[17:29:03.773]             seq.int <- base::seq.int
[17:29:03.773]             signalCondition <- base::signalCondition
[17:29:03.773]             sys.calls <- base::sys.calls
[17:29:03.773]             `[[` <- base::`[[`
[17:29:03.773]             `+` <- base::`+`
[17:29:03.773]             `<<-` <- base::`<<-`
[17:29:03.773]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:03.773]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:03.773]                   3L)]
[17:29:03.773]             }
[17:29:03.773]             function(cond) {
[17:29:03.773]                 is_error <- inherits(cond, "error")
[17:29:03.773]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:03.773]                   NULL)
[17:29:03.773]                 if (is_error) {
[17:29:03.773]                   sessionInformation <- function() {
[17:29:03.773]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:03.773]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:03.773]                       search = base::search(), system = base::Sys.info())
[17:29:03.773]                   }
[17:29:03.773]                   ...future.conditions[[length(...future.conditions) + 
[17:29:03.773]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:03.773]                     cond$call), session = sessionInformation(), 
[17:29:03.773]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:03.773]                   signalCondition(cond)
[17:29:03.773]                 }
[17:29:03.773]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:03.773]                 "immediateCondition"))) {
[17:29:03.773]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:03.773]                   ...future.conditions[[length(...future.conditions) + 
[17:29:03.773]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:03.773]                   if (TRUE && !signal) {
[17:29:03.773]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:03.773]                     {
[17:29:03.773]                       inherits <- base::inherits
[17:29:03.773]                       invokeRestart <- base::invokeRestart
[17:29:03.773]                       is.null <- base::is.null
[17:29:03.773]                       muffled <- FALSE
[17:29:03.773]                       if (inherits(cond, "message")) {
[17:29:03.773]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:03.773]                         if (muffled) 
[17:29:03.773]                           invokeRestart("muffleMessage")
[17:29:03.773]                       }
[17:29:03.773]                       else if (inherits(cond, "warning")) {
[17:29:03.773]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:03.773]                         if (muffled) 
[17:29:03.773]                           invokeRestart("muffleWarning")
[17:29:03.773]                       }
[17:29:03.773]                       else if (inherits(cond, "condition")) {
[17:29:03.773]                         if (!is.null(pattern)) {
[17:29:03.773]                           computeRestarts <- base::computeRestarts
[17:29:03.773]                           grepl <- base::grepl
[17:29:03.773]                           restarts <- computeRestarts(cond)
[17:29:03.773]                           for (restart in restarts) {
[17:29:03.773]                             name <- restart$name
[17:29:03.773]                             if (is.null(name)) 
[17:29:03.773]                               next
[17:29:03.773]                             if (!grepl(pattern, name)) 
[17:29:03.773]                               next
[17:29:03.773]                             invokeRestart(restart)
[17:29:03.773]                             muffled <- TRUE
[17:29:03.773]                             break
[17:29:03.773]                           }
[17:29:03.773]                         }
[17:29:03.773]                       }
[17:29:03.773]                       invisible(muffled)
[17:29:03.773]                     }
[17:29:03.773]                     muffleCondition(cond, pattern = "^muffle")
[17:29:03.773]                   }
[17:29:03.773]                 }
[17:29:03.773]                 else {
[17:29:03.773]                   if (TRUE) {
[17:29:03.773]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:03.773]                     {
[17:29:03.773]                       inherits <- base::inherits
[17:29:03.773]                       invokeRestart <- base::invokeRestart
[17:29:03.773]                       is.null <- base::is.null
[17:29:03.773]                       muffled <- FALSE
[17:29:03.773]                       if (inherits(cond, "message")) {
[17:29:03.773]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:03.773]                         if (muffled) 
[17:29:03.773]                           invokeRestart("muffleMessage")
[17:29:03.773]                       }
[17:29:03.773]                       else if (inherits(cond, "warning")) {
[17:29:03.773]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:03.773]                         if (muffled) 
[17:29:03.773]                           invokeRestart("muffleWarning")
[17:29:03.773]                       }
[17:29:03.773]                       else if (inherits(cond, "condition")) {
[17:29:03.773]                         if (!is.null(pattern)) {
[17:29:03.773]                           computeRestarts <- base::computeRestarts
[17:29:03.773]                           grepl <- base::grepl
[17:29:03.773]                           restarts <- computeRestarts(cond)
[17:29:03.773]                           for (restart in restarts) {
[17:29:03.773]                             name <- restart$name
[17:29:03.773]                             if (is.null(name)) 
[17:29:03.773]                               next
[17:29:03.773]                             if (!grepl(pattern, name)) 
[17:29:03.773]                               next
[17:29:03.773]                             invokeRestart(restart)
[17:29:03.773]                             muffled <- TRUE
[17:29:03.773]                             break
[17:29:03.773]                           }
[17:29:03.773]                         }
[17:29:03.773]                       }
[17:29:03.773]                       invisible(muffled)
[17:29:03.773]                     }
[17:29:03.773]                     muffleCondition(cond, pattern = "^muffle")
[17:29:03.773]                   }
[17:29:03.773]                 }
[17:29:03.773]             }
[17:29:03.773]         }))
[17:29:03.773]     }, error = function(ex) {
[17:29:03.773]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:03.773]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:03.773]                 ...future.rng), started = ...future.startTime, 
[17:29:03.773]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:03.773]             version = "1.8"), class = "FutureResult")
[17:29:03.773]     }, finally = {
[17:29:03.773]         if (!identical(...future.workdir, getwd())) 
[17:29:03.773]             setwd(...future.workdir)
[17:29:03.773]         {
[17:29:03.773]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:03.773]                 ...future.oldOptions$nwarnings <- NULL
[17:29:03.773]             }
[17:29:03.773]             base::options(...future.oldOptions)
[17:29:03.773]             if (.Platform$OS.type == "windows") {
[17:29:03.773]                 old_names <- names(...future.oldEnvVars)
[17:29:03.773]                 envs <- base::Sys.getenv()
[17:29:03.773]                 names <- names(envs)
[17:29:03.773]                 common <- intersect(names, old_names)
[17:29:03.773]                 added <- setdiff(names, old_names)
[17:29:03.773]                 removed <- setdiff(old_names, names)
[17:29:03.773]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:03.773]                   envs[common]]
[17:29:03.773]                 NAMES <- toupper(changed)
[17:29:03.773]                 args <- list()
[17:29:03.773]                 for (kk in seq_along(NAMES)) {
[17:29:03.773]                   name <- changed[[kk]]
[17:29:03.773]                   NAME <- NAMES[[kk]]
[17:29:03.773]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:03.773]                     next
[17:29:03.773]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:03.773]                 }
[17:29:03.773]                 NAMES <- toupper(added)
[17:29:03.773]                 for (kk in seq_along(NAMES)) {
[17:29:03.773]                   name <- added[[kk]]
[17:29:03.773]                   NAME <- NAMES[[kk]]
[17:29:03.773]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:03.773]                     next
[17:29:03.773]                   args[[name]] <- ""
[17:29:03.773]                 }
[17:29:03.773]                 NAMES <- toupper(removed)
[17:29:03.773]                 for (kk in seq_along(NAMES)) {
[17:29:03.773]                   name <- removed[[kk]]
[17:29:03.773]                   NAME <- NAMES[[kk]]
[17:29:03.773]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:03.773]                     next
[17:29:03.773]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:03.773]                 }
[17:29:03.773]                 if (length(args) > 0) 
[17:29:03.773]                   base::do.call(base::Sys.setenv, args = args)
[17:29:03.773]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:03.773]             }
[17:29:03.773]             else {
[17:29:03.773]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:03.773]             }
[17:29:03.773]             {
[17:29:03.773]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:03.773]                   0L) {
[17:29:03.773]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:03.773]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:03.773]                   base::options(opts)
[17:29:03.773]                 }
[17:29:03.773]                 {
[17:29:03.773]                   {
[17:29:03.773]                     NULL
[17:29:03.773]                     RNGkind("Mersenne-Twister")
[17:29:03.773]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:03.773]                       inherits = FALSE)
[17:29:03.773]                   }
[17:29:03.773]                   options(future.plan = NULL)
[17:29:03.773]                   if (is.na(NA_character_)) 
[17:29:03.773]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:03.773]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:03.773]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:03.773]                     .init = FALSE)
[17:29:03.773]                 }
[17:29:03.773]             }
[17:29:03.773]         }
[17:29:03.773]     })
[17:29:03.773]     if (TRUE) {
[17:29:03.773]         base::sink(type = "output", split = FALSE)
[17:29:03.773]         if (TRUE) {
[17:29:03.773]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:03.773]         }
[17:29:03.773]         else {
[17:29:03.773]             ...future.result["stdout"] <- base::list(NULL)
[17:29:03.773]         }
[17:29:03.773]         base::close(...future.stdout)
[17:29:03.773]         ...future.stdout <- NULL
[17:29:03.773]     }
[17:29:03.773]     ...future.result$conditions <- ...future.conditions
[17:29:03.773]     ...future.result$finished <- base::Sys.time()
[17:29:03.773]     ...future.result
[17:29:03.773] }
[17:29:03.777] plan(): Setting new future strategy stack:
[17:29:03.778] List of future strategies:
[17:29:03.778] 1. sequential:
[17:29:03.778]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:03.778]    - tweaked: FALSE
[17:29:03.778]    - call: NULL
[17:29:03.778] plan(): nbrOfWorkers() = 1
[17:29:03.780] plan(): Setting new future strategy stack:
[17:29:03.780] List of future strategies:
[17:29:03.780] 1. sequential:
[17:29:03.780]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:03.780]    - tweaked: FALSE
[17:29:03.780]    - call: plan(strategy)
[17:29:03.781] plan(): nbrOfWorkers() = 1
[17:29:03.781] SequentialFuture started (and completed)
[17:29:03.781] - Launch lazy future ... done
[17:29:03.782] run() for 'SequentialFuture' ... done
[17:29:03.784] resolved() for 'SequentialFuture' ...
[17:29:03.785] - state: 'finished'
[17:29:03.785] - run: TRUE
[17:29:03.785] - result: 'FutureResult'
[17:29:03.786] resolved() for 'SequentialFuture' ... done
[17:29:03.786] Future #1
[17:29:03.786]  length: 2 (resolved future 1)
[17:29:03.787] resolved() for 'SequentialFuture' ...
[17:29:03.787] - state: 'finished'
[17:29:03.787] - run: TRUE
[17:29:03.788] - result: 'FutureResult'
[17:29:03.788] resolved() for 'SequentialFuture' ... done
[17:29:03.788] Future #2
[17:29:03.789]  length: 1 (resolved future 2)
[17:29:03.789]  length: 0 (resolved future 3)
[17:29:03.789] resolve() on list ... DONE
[17:29:03.790] resolved() for 'SequentialFuture' ...
[17:29:03.790] - state: 'finished'
[17:29:03.790] - run: TRUE
[17:29:03.791] - result: 'FutureResult'
[17:29:03.791] resolved() for 'SequentialFuture' ... done
[17:29:03.791] resolved() for 'SequentialFuture' ...
[17:29:03.792] - state: 'finished'
[17:29:03.792] - run: TRUE
[17:29:03.792] - result: 'FutureResult'
[17:29:03.793] resolved() for 'SequentialFuture' ... done
[17:29:03.793] getGlobalsAndPackages() ...
[17:29:03.793] Searching for globals...
[17:29:03.794] 
[17:29:03.794] Searching for globals ... DONE
[17:29:03.795] - globals: [0] <none>
[17:29:03.795] getGlobalsAndPackages() ... DONE
[17:29:03.796] getGlobalsAndPackages() ...
[17:29:03.796] Searching for globals...
[17:29:03.797] 
[17:29:03.797] Searching for globals ... DONE
[17:29:03.797] - globals: [0] <none>
[17:29:03.797] getGlobalsAndPackages() ... DONE
[17:29:03.798] resolve() on list ...
[17:29:03.798]  recursive: 0
[17:29:03.798]  length: 3
[17:29:03.799]  elements: 'a', 'b', ''
[17:29:03.799] run() for 'Future' ...
[17:29:03.800] - state: 'created'
[17:29:03.800] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:03.800] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:03.801] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:03.801]   - Field: 'label'
[17:29:03.801]   - Field: 'local'
[17:29:03.801]   - Field: 'owner'
[17:29:03.801]   - Field: 'envir'
[17:29:03.802]   - Field: 'packages'
[17:29:03.802]   - Field: 'gc'
[17:29:03.802]   - Field: 'conditions'
[17:29:03.802]   - Field: 'expr'
[17:29:03.802]   - Field: 'uuid'
[17:29:03.803]   - Field: 'seed'
[17:29:03.803]   - Field: 'version'
[17:29:03.803]   - Field: 'result'
[17:29:03.803]   - Field: 'asynchronous'
[17:29:03.803]   - Field: 'calls'
[17:29:03.804]   - Field: 'globals'
[17:29:03.804]   - Field: 'stdout'
[17:29:03.804]   - Field: 'earlySignal'
[17:29:03.804]   - Field: 'lazy'
[17:29:03.804]   - Field: 'state'
[17:29:03.804] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:03.805] - Launch lazy future ...
[17:29:03.805] Packages needed by the future expression (n = 0): <none>
[17:29:03.805] Packages needed by future strategies (n = 0): <none>
[17:29:03.806] {
[17:29:03.806]     {
[17:29:03.806]         {
[17:29:03.806]             ...future.startTime <- base::Sys.time()
[17:29:03.806]             {
[17:29:03.806]                 {
[17:29:03.806]                   {
[17:29:03.806]                     base::local({
[17:29:03.806]                       has_future <- base::requireNamespace("future", 
[17:29:03.806]                         quietly = TRUE)
[17:29:03.806]                       if (has_future) {
[17:29:03.806]                         ns <- base::getNamespace("future")
[17:29:03.806]                         version <- ns[[".package"]][["version"]]
[17:29:03.806]                         if (is.null(version)) 
[17:29:03.806]                           version <- utils::packageVersion("future")
[17:29:03.806]                       }
[17:29:03.806]                       else {
[17:29:03.806]                         version <- NULL
[17:29:03.806]                       }
[17:29:03.806]                       if (!has_future || version < "1.8.0") {
[17:29:03.806]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:03.806]                           "", base::R.version$version.string), 
[17:29:03.806]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:03.806]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:03.806]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:03.806]                             "release", "version")], collapse = " "), 
[17:29:03.806]                           hostname = base::Sys.info()[["nodename"]])
[17:29:03.806]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:03.806]                           info)
[17:29:03.806]                         info <- base::paste(info, collapse = "; ")
[17:29:03.806]                         if (!has_future) {
[17:29:03.806]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:03.806]                             info)
[17:29:03.806]                         }
[17:29:03.806]                         else {
[17:29:03.806]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:03.806]                             info, version)
[17:29:03.806]                         }
[17:29:03.806]                         base::stop(msg)
[17:29:03.806]                       }
[17:29:03.806]                     })
[17:29:03.806]                   }
[17:29:03.806]                   ...future.strategy.old <- future::plan("list")
[17:29:03.806]                   options(future.plan = NULL)
[17:29:03.806]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:03.806]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:03.806]                 }
[17:29:03.806]                 ...future.workdir <- getwd()
[17:29:03.806]             }
[17:29:03.806]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:03.806]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:03.806]         }
[17:29:03.806]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:03.806]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:03.806]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:03.806]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:03.806]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:03.806]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:03.806]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:03.806]             base::names(...future.oldOptions))
[17:29:03.806]     }
[17:29:03.806]     if (FALSE) {
[17:29:03.806]     }
[17:29:03.806]     else {
[17:29:03.806]         if (TRUE) {
[17:29:03.806]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:03.806]                 open = "w")
[17:29:03.806]         }
[17:29:03.806]         else {
[17:29:03.806]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:03.806]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:03.806]         }
[17:29:03.806]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:03.806]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:03.806]             base::sink(type = "output", split = FALSE)
[17:29:03.806]             base::close(...future.stdout)
[17:29:03.806]         }, add = TRUE)
[17:29:03.806]     }
[17:29:03.806]     ...future.frame <- base::sys.nframe()
[17:29:03.806]     ...future.conditions <- base::list()
[17:29:03.806]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:03.806]     if (FALSE) {
[17:29:03.806]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:03.806]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:03.806]     }
[17:29:03.806]     ...future.result <- base::tryCatch({
[17:29:03.806]         base::withCallingHandlers({
[17:29:03.806]             ...future.value <- base::withVisible(base::local(1))
[17:29:03.806]             future::FutureResult(value = ...future.value$value, 
[17:29:03.806]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:03.806]                   ...future.rng), globalenv = if (FALSE) 
[17:29:03.806]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:03.806]                     ...future.globalenv.names))
[17:29:03.806]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:03.806]         }, condition = base::local({
[17:29:03.806]             c <- base::c
[17:29:03.806]             inherits <- base::inherits
[17:29:03.806]             invokeRestart <- base::invokeRestart
[17:29:03.806]             length <- base::length
[17:29:03.806]             list <- base::list
[17:29:03.806]             seq.int <- base::seq.int
[17:29:03.806]             signalCondition <- base::signalCondition
[17:29:03.806]             sys.calls <- base::sys.calls
[17:29:03.806]             `[[` <- base::`[[`
[17:29:03.806]             `+` <- base::`+`
[17:29:03.806]             `<<-` <- base::`<<-`
[17:29:03.806]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:03.806]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:03.806]                   3L)]
[17:29:03.806]             }
[17:29:03.806]             function(cond) {
[17:29:03.806]                 is_error <- inherits(cond, "error")
[17:29:03.806]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:03.806]                   NULL)
[17:29:03.806]                 if (is_error) {
[17:29:03.806]                   sessionInformation <- function() {
[17:29:03.806]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:03.806]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:03.806]                       search = base::search(), system = base::Sys.info())
[17:29:03.806]                   }
[17:29:03.806]                   ...future.conditions[[length(...future.conditions) + 
[17:29:03.806]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:03.806]                     cond$call), session = sessionInformation(), 
[17:29:03.806]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:03.806]                   signalCondition(cond)
[17:29:03.806]                 }
[17:29:03.806]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:03.806]                 "immediateCondition"))) {
[17:29:03.806]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:03.806]                   ...future.conditions[[length(...future.conditions) + 
[17:29:03.806]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:03.806]                   if (TRUE && !signal) {
[17:29:03.806]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:03.806]                     {
[17:29:03.806]                       inherits <- base::inherits
[17:29:03.806]                       invokeRestart <- base::invokeRestart
[17:29:03.806]                       is.null <- base::is.null
[17:29:03.806]                       muffled <- FALSE
[17:29:03.806]                       if (inherits(cond, "message")) {
[17:29:03.806]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:03.806]                         if (muffled) 
[17:29:03.806]                           invokeRestart("muffleMessage")
[17:29:03.806]                       }
[17:29:03.806]                       else if (inherits(cond, "warning")) {
[17:29:03.806]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:03.806]                         if (muffled) 
[17:29:03.806]                           invokeRestart("muffleWarning")
[17:29:03.806]                       }
[17:29:03.806]                       else if (inherits(cond, "condition")) {
[17:29:03.806]                         if (!is.null(pattern)) {
[17:29:03.806]                           computeRestarts <- base::computeRestarts
[17:29:03.806]                           grepl <- base::grepl
[17:29:03.806]                           restarts <- computeRestarts(cond)
[17:29:03.806]                           for (restart in restarts) {
[17:29:03.806]                             name <- restart$name
[17:29:03.806]                             if (is.null(name)) 
[17:29:03.806]                               next
[17:29:03.806]                             if (!grepl(pattern, name)) 
[17:29:03.806]                               next
[17:29:03.806]                             invokeRestart(restart)
[17:29:03.806]                             muffled <- TRUE
[17:29:03.806]                             break
[17:29:03.806]                           }
[17:29:03.806]                         }
[17:29:03.806]                       }
[17:29:03.806]                       invisible(muffled)
[17:29:03.806]                     }
[17:29:03.806]                     muffleCondition(cond, pattern = "^muffle")
[17:29:03.806]                   }
[17:29:03.806]                 }
[17:29:03.806]                 else {
[17:29:03.806]                   if (TRUE) {
[17:29:03.806]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:03.806]                     {
[17:29:03.806]                       inherits <- base::inherits
[17:29:03.806]                       invokeRestart <- base::invokeRestart
[17:29:03.806]                       is.null <- base::is.null
[17:29:03.806]                       muffled <- FALSE
[17:29:03.806]                       if (inherits(cond, "message")) {
[17:29:03.806]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:03.806]                         if (muffled) 
[17:29:03.806]                           invokeRestart("muffleMessage")
[17:29:03.806]                       }
[17:29:03.806]                       else if (inherits(cond, "warning")) {
[17:29:03.806]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:03.806]                         if (muffled) 
[17:29:03.806]                           invokeRestart("muffleWarning")
[17:29:03.806]                       }
[17:29:03.806]                       else if (inherits(cond, "condition")) {
[17:29:03.806]                         if (!is.null(pattern)) {
[17:29:03.806]                           computeRestarts <- base::computeRestarts
[17:29:03.806]                           grepl <- base::grepl
[17:29:03.806]                           restarts <- computeRestarts(cond)
[17:29:03.806]                           for (restart in restarts) {
[17:29:03.806]                             name <- restart$name
[17:29:03.806]                             if (is.null(name)) 
[17:29:03.806]                               next
[17:29:03.806]                             if (!grepl(pattern, name)) 
[17:29:03.806]                               next
[17:29:03.806]                             invokeRestart(restart)
[17:29:03.806]                             muffled <- TRUE
[17:29:03.806]                             break
[17:29:03.806]                           }
[17:29:03.806]                         }
[17:29:03.806]                       }
[17:29:03.806]                       invisible(muffled)
[17:29:03.806]                     }
[17:29:03.806]                     muffleCondition(cond, pattern = "^muffle")
[17:29:03.806]                   }
[17:29:03.806]                 }
[17:29:03.806]             }
[17:29:03.806]         }))
[17:29:03.806]     }, error = function(ex) {
[17:29:03.806]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:03.806]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:03.806]                 ...future.rng), started = ...future.startTime, 
[17:29:03.806]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:03.806]             version = "1.8"), class = "FutureResult")
[17:29:03.806]     }, finally = {
[17:29:03.806]         if (!identical(...future.workdir, getwd())) 
[17:29:03.806]             setwd(...future.workdir)
[17:29:03.806]         {
[17:29:03.806]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:03.806]                 ...future.oldOptions$nwarnings <- NULL
[17:29:03.806]             }
[17:29:03.806]             base::options(...future.oldOptions)
[17:29:03.806]             if (.Platform$OS.type == "windows") {
[17:29:03.806]                 old_names <- names(...future.oldEnvVars)
[17:29:03.806]                 envs <- base::Sys.getenv()
[17:29:03.806]                 names <- names(envs)
[17:29:03.806]                 common <- intersect(names, old_names)
[17:29:03.806]                 added <- setdiff(names, old_names)
[17:29:03.806]                 removed <- setdiff(old_names, names)
[17:29:03.806]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:03.806]                   envs[common]]
[17:29:03.806]                 NAMES <- toupper(changed)
[17:29:03.806]                 args <- list()
[17:29:03.806]                 for (kk in seq_along(NAMES)) {
[17:29:03.806]                   name <- changed[[kk]]
[17:29:03.806]                   NAME <- NAMES[[kk]]
[17:29:03.806]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:03.806]                     next
[17:29:03.806]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:03.806]                 }
[17:29:03.806]                 NAMES <- toupper(added)
[17:29:03.806]                 for (kk in seq_along(NAMES)) {
[17:29:03.806]                   name <- added[[kk]]
[17:29:03.806]                   NAME <- NAMES[[kk]]
[17:29:03.806]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:03.806]                     next
[17:29:03.806]                   args[[name]] <- ""
[17:29:03.806]                 }
[17:29:03.806]                 NAMES <- toupper(removed)
[17:29:03.806]                 for (kk in seq_along(NAMES)) {
[17:29:03.806]                   name <- removed[[kk]]
[17:29:03.806]                   NAME <- NAMES[[kk]]
[17:29:03.806]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:03.806]                     next
[17:29:03.806]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:03.806]                 }
[17:29:03.806]                 if (length(args) > 0) 
[17:29:03.806]                   base::do.call(base::Sys.setenv, args = args)
[17:29:03.806]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:03.806]             }
[17:29:03.806]             else {
[17:29:03.806]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:03.806]             }
[17:29:03.806]             {
[17:29:03.806]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:03.806]                   0L) {
[17:29:03.806]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:03.806]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:03.806]                   base::options(opts)
[17:29:03.806]                 }
[17:29:03.806]                 {
[17:29:03.806]                   {
[17:29:03.806]                     NULL
[17:29:03.806]                     RNGkind("Mersenne-Twister")
[17:29:03.806]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:03.806]                       inherits = FALSE)
[17:29:03.806]                   }
[17:29:03.806]                   options(future.plan = NULL)
[17:29:03.806]                   if (is.na(NA_character_)) 
[17:29:03.806]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:03.806]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:03.806]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:03.806]                     .init = FALSE)
[17:29:03.806]                 }
[17:29:03.806]             }
[17:29:03.806]         }
[17:29:03.806]     })
[17:29:03.806]     if (TRUE) {
[17:29:03.806]         base::sink(type = "output", split = FALSE)
[17:29:03.806]         if (TRUE) {
[17:29:03.806]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:03.806]         }
[17:29:03.806]         else {
[17:29:03.806]             ...future.result["stdout"] <- base::list(NULL)
[17:29:03.806]         }
[17:29:03.806]         base::close(...future.stdout)
[17:29:03.806]         ...future.stdout <- NULL
[17:29:03.806]     }
[17:29:03.806]     ...future.result$conditions <- ...future.conditions
[17:29:03.806]     ...future.result$finished <- base::Sys.time()
[17:29:03.806]     ...future.result
[17:29:03.806] }
[17:29:03.811] plan(): Setting new future strategy stack:
[17:29:03.811] List of future strategies:
[17:29:03.811] 1. sequential:
[17:29:03.811]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:03.811]    - tweaked: FALSE
[17:29:03.811]    - call: NULL
[17:29:03.812] plan(): nbrOfWorkers() = 1
[17:29:03.813] plan(): Setting new future strategy stack:
[17:29:03.813] List of future strategies:
[17:29:03.813] 1. sequential:
[17:29:03.813]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:03.813]    - tweaked: FALSE
[17:29:03.813]    - call: plan(strategy)
[17:29:03.814] plan(): nbrOfWorkers() = 1
[17:29:03.814] SequentialFuture started (and completed)
[17:29:03.814] - Launch lazy future ... done
[17:29:03.814] run() for 'SequentialFuture' ... done
[17:29:03.815] resolved() for 'SequentialFuture' ...
[17:29:03.815] - state: 'finished'
[17:29:03.815] - run: TRUE
[17:29:03.815] - result: 'FutureResult'
[17:29:03.815] resolved() for 'SequentialFuture' ... done
[17:29:03.816] Future #1
[17:29:03.816]  length: 2 (resolved future 1)
[17:29:03.816] run() for 'Future' ...
[17:29:03.816] - state: 'created'
[17:29:03.816] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:03.817] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:03.817] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:03.817]   - Field: 'label'
[17:29:03.817]   - Field: 'local'
[17:29:03.818]   - Field: 'owner'
[17:29:03.818]   - Field: 'envir'
[17:29:03.818]   - Field: 'packages'
[17:29:03.818]   - Field: 'gc'
[17:29:03.819]   - Field: 'conditions'
[17:29:03.819]   - Field: 'expr'
[17:29:03.819]   - Field: 'uuid'
[17:29:03.819]   - Field: 'seed'
[17:29:03.820]   - Field: 'version'
[17:29:03.820]   - Field: 'result'
[17:29:03.820]   - Field: 'asynchronous'
[17:29:03.821]   - Field: 'calls'
[17:29:03.821]   - Field: 'globals'
[17:29:03.821]   - Field: 'stdout'
[17:29:03.822]   - Field: 'earlySignal'
[17:29:03.822]   - Field: 'lazy'
[17:29:03.822]   - Field: 'state'
[17:29:03.823] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:03.823] - Launch lazy future ...
[17:29:03.824] Packages needed by the future expression (n = 0): <none>
[17:29:03.824] Packages needed by future strategies (n = 0): <none>
[17:29:03.825] {
[17:29:03.825]     {
[17:29:03.825]         {
[17:29:03.825]             ...future.startTime <- base::Sys.time()
[17:29:03.825]             {
[17:29:03.825]                 {
[17:29:03.825]                   {
[17:29:03.825]                     base::local({
[17:29:03.825]                       has_future <- base::requireNamespace("future", 
[17:29:03.825]                         quietly = TRUE)
[17:29:03.825]                       if (has_future) {
[17:29:03.825]                         ns <- base::getNamespace("future")
[17:29:03.825]                         version <- ns[[".package"]][["version"]]
[17:29:03.825]                         if (is.null(version)) 
[17:29:03.825]                           version <- utils::packageVersion("future")
[17:29:03.825]                       }
[17:29:03.825]                       else {
[17:29:03.825]                         version <- NULL
[17:29:03.825]                       }
[17:29:03.825]                       if (!has_future || version < "1.8.0") {
[17:29:03.825]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:03.825]                           "", base::R.version$version.string), 
[17:29:03.825]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:03.825]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:03.825]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:03.825]                             "release", "version")], collapse = " "), 
[17:29:03.825]                           hostname = base::Sys.info()[["nodename"]])
[17:29:03.825]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:03.825]                           info)
[17:29:03.825]                         info <- base::paste(info, collapse = "; ")
[17:29:03.825]                         if (!has_future) {
[17:29:03.825]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:03.825]                             info)
[17:29:03.825]                         }
[17:29:03.825]                         else {
[17:29:03.825]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:03.825]                             info, version)
[17:29:03.825]                         }
[17:29:03.825]                         base::stop(msg)
[17:29:03.825]                       }
[17:29:03.825]                     })
[17:29:03.825]                   }
[17:29:03.825]                   ...future.strategy.old <- future::plan("list")
[17:29:03.825]                   options(future.plan = NULL)
[17:29:03.825]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:03.825]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:03.825]                 }
[17:29:03.825]                 ...future.workdir <- getwd()
[17:29:03.825]             }
[17:29:03.825]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:03.825]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:03.825]         }
[17:29:03.825]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:03.825]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:03.825]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:03.825]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:03.825]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:03.825]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:03.825]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:03.825]             base::names(...future.oldOptions))
[17:29:03.825]     }
[17:29:03.825]     if (FALSE) {
[17:29:03.825]     }
[17:29:03.825]     else {
[17:29:03.825]         if (TRUE) {
[17:29:03.825]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:03.825]                 open = "w")
[17:29:03.825]         }
[17:29:03.825]         else {
[17:29:03.825]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:03.825]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:03.825]         }
[17:29:03.825]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:03.825]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:03.825]             base::sink(type = "output", split = FALSE)
[17:29:03.825]             base::close(...future.stdout)
[17:29:03.825]         }, add = TRUE)
[17:29:03.825]     }
[17:29:03.825]     ...future.frame <- base::sys.nframe()
[17:29:03.825]     ...future.conditions <- base::list()
[17:29:03.825]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:03.825]     if (FALSE) {
[17:29:03.825]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:03.825]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:03.825]     }
[17:29:03.825]     ...future.result <- base::tryCatch({
[17:29:03.825]         base::withCallingHandlers({
[17:29:03.825]             ...future.value <- base::withVisible(base::local(2))
[17:29:03.825]             future::FutureResult(value = ...future.value$value, 
[17:29:03.825]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:03.825]                   ...future.rng), globalenv = if (FALSE) 
[17:29:03.825]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:03.825]                     ...future.globalenv.names))
[17:29:03.825]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:03.825]         }, condition = base::local({
[17:29:03.825]             c <- base::c
[17:29:03.825]             inherits <- base::inherits
[17:29:03.825]             invokeRestart <- base::invokeRestart
[17:29:03.825]             length <- base::length
[17:29:03.825]             list <- base::list
[17:29:03.825]             seq.int <- base::seq.int
[17:29:03.825]             signalCondition <- base::signalCondition
[17:29:03.825]             sys.calls <- base::sys.calls
[17:29:03.825]             `[[` <- base::`[[`
[17:29:03.825]             `+` <- base::`+`
[17:29:03.825]             `<<-` <- base::`<<-`
[17:29:03.825]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:03.825]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:03.825]                   3L)]
[17:29:03.825]             }
[17:29:03.825]             function(cond) {
[17:29:03.825]                 is_error <- inherits(cond, "error")
[17:29:03.825]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:03.825]                   NULL)
[17:29:03.825]                 if (is_error) {
[17:29:03.825]                   sessionInformation <- function() {
[17:29:03.825]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:03.825]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:03.825]                       search = base::search(), system = base::Sys.info())
[17:29:03.825]                   }
[17:29:03.825]                   ...future.conditions[[length(...future.conditions) + 
[17:29:03.825]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:03.825]                     cond$call), session = sessionInformation(), 
[17:29:03.825]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:03.825]                   signalCondition(cond)
[17:29:03.825]                 }
[17:29:03.825]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:03.825]                 "immediateCondition"))) {
[17:29:03.825]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:03.825]                   ...future.conditions[[length(...future.conditions) + 
[17:29:03.825]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:03.825]                   if (TRUE && !signal) {
[17:29:03.825]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:03.825]                     {
[17:29:03.825]                       inherits <- base::inherits
[17:29:03.825]                       invokeRestart <- base::invokeRestart
[17:29:03.825]                       is.null <- base::is.null
[17:29:03.825]                       muffled <- FALSE
[17:29:03.825]                       if (inherits(cond, "message")) {
[17:29:03.825]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:03.825]                         if (muffled) 
[17:29:03.825]                           invokeRestart("muffleMessage")
[17:29:03.825]                       }
[17:29:03.825]                       else if (inherits(cond, "warning")) {
[17:29:03.825]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:03.825]                         if (muffled) 
[17:29:03.825]                           invokeRestart("muffleWarning")
[17:29:03.825]                       }
[17:29:03.825]                       else if (inherits(cond, "condition")) {
[17:29:03.825]                         if (!is.null(pattern)) {
[17:29:03.825]                           computeRestarts <- base::computeRestarts
[17:29:03.825]                           grepl <- base::grepl
[17:29:03.825]                           restarts <- computeRestarts(cond)
[17:29:03.825]                           for (restart in restarts) {
[17:29:03.825]                             name <- restart$name
[17:29:03.825]                             if (is.null(name)) 
[17:29:03.825]                               next
[17:29:03.825]                             if (!grepl(pattern, name)) 
[17:29:03.825]                               next
[17:29:03.825]                             invokeRestart(restart)
[17:29:03.825]                             muffled <- TRUE
[17:29:03.825]                             break
[17:29:03.825]                           }
[17:29:03.825]                         }
[17:29:03.825]                       }
[17:29:03.825]                       invisible(muffled)
[17:29:03.825]                     }
[17:29:03.825]                     muffleCondition(cond, pattern = "^muffle")
[17:29:03.825]                   }
[17:29:03.825]                 }
[17:29:03.825]                 else {
[17:29:03.825]                   if (TRUE) {
[17:29:03.825]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:03.825]                     {
[17:29:03.825]                       inherits <- base::inherits
[17:29:03.825]                       invokeRestart <- base::invokeRestart
[17:29:03.825]                       is.null <- base::is.null
[17:29:03.825]                       muffled <- FALSE
[17:29:03.825]                       if (inherits(cond, "message")) {
[17:29:03.825]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:03.825]                         if (muffled) 
[17:29:03.825]                           invokeRestart("muffleMessage")
[17:29:03.825]                       }
[17:29:03.825]                       else if (inherits(cond, "warning")) {
[17:29:03.825]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:03.825]                         if (muffled) 
[17:29:03.825]                           invokeRestart("muffleWarning")
[17:29:03.825]                       }
[17:29:03.825]                       else if (inherits(cond, "condition")) {
[17:29:03.825]                         if (!is.null(pattern)) {
[17:29:03.825]                           computeRestarts <- base::computeRestarts
[17:29:03.825]                           grepl <- base::grepl
[17:29:03.825]                           restarts <- computeRestarts(cond)
[17:29:03.825]                           for (restart in restarts) {
[17:29:03.825]                             name <- restart$name
[17:29:03.825]                             if (is.null(name)) 
[17:29:03.825]                               next
[17:29:03.825]                             if (!grepl(pattern, name)) 
[17:29:03.825]                               next
[17:29:03.825]                             invokeRestart(restart)
[17:29:03.825]                             muffled <- TRUE
[17:29:03.825]                             break
[17:29:03.825]                           }
[17:29:03.825]                         }
[17:29:03.825]                       }
[17:29:03.825]                       invisible(muffled)
[17:29:03.825]                     }
[17:29:03.825]                     muffleCondition(cond, pattern = "^muffle")
[17:29:03.825]                   }
[17:29:03.825]                 }
[17:29:03.825]             }
[17:29:03.825]         }))
[17:29:03.825]     }, error = function(ex) {
[17:29:03.825]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:03.825]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:03.825]                 ...future.rng), started = ...future.startTime, 
[17:29:03.825]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:03.825]             version = "1.8"), class = "FutureResult")
[17:29:03.825]     }, finally = {
[17:29:03.825]         if (!identical(...future.workdir, getwd())) 
[17:29:03.825]             setwd(...future.workdir)
[17:29:03.825]         {
[17:29:03.825]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:03.825]                 ...future.oldOptions$nwarnings <- NULL
[17:29:03.825]             }
[17:29:03.825]             base::options(...future.oldOptions)
[17:29:03.825]             if (.Platform$OS.type == "windows") {
[17:29:03.825]                 old_names <- names(...future.oldEnvVars)
[17:29:03.825]                 envs <- base::Sys.getenv()
[17:29:03.825]                 names <- names(envs)
[17:29:03.825]                 common <- intersect(names, old_names)
[17:29:03.825]                 added <- setdiff(names, old_names)
[17:29:03.825]                 removed <- setdiff(old_names, names)
[17:29:03.825]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:03.825]                   envs[common]]
[17:29:03.825]                 NAMES <- toupper(changed)
[17:29:03.825]                 args <- list()
[17:29:03.825]                 for (kk in seq_along(NAMES)) {
[17:29:03.825]                   name <- changed[[kk]]
[17:29:03.825]                   NAME <- NAMES[[kk]]
[17:29:03.825]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:03.825]                     next
[17:29:03.825]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:03.825]                 }
[17:29:03.825]                 NAMES <- toupper(added)
[17:29:03.825]                 for (kk in seq_along(NAMES)) {
[17:29:03.825]                   name <- added[[kk]]
[17:29:03.825]                   NAME <- NAMES[[kk]]
[17:29:03.825]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:03.825]                     next
[17:29:03.825]                   args[[name]] <- ""
[17:29:03.825]                 }
[17:29:03.825]                 NAMES <- toupper(removed)
[17:29:03.825]                 for (kk in seq_along(NAMES)) {
[17:29:03.825]                   name <- removed[[kk]]
[17:29:03.825]                   NAME <- NAMES[[kk]]
[17:29:03.825]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:03.825]                     next
[17:29:03.825]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:03.825]                 }
[17:29:03.825]                 if (length(args) > 0) 
[17:29:03.825]                   base::do.call(base::Sys.setenv, args = args)
[17:29:03.825]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:03.825]             }
[17:29:03.825]             else {
[17:29:03.825]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:03.825]             }
[17:29:03.825]             {
[17:29:03.825]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:03.825]                   0L) {
[17:29:03.825]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:03.825]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:03.825]                   base::options(opts)
[17:29:03.825]                 }
[17:29:03.825]                 {
[17:29:03.825]                   {
[17:29:03.825]                     NULL
[17:29:03.825]                     RNGkind("Mersenne-Twister")
[17:29:03.825]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:03.825]                       inherits = FALSE)
[17:29:03.825]                   }
[17:29:03.825]                   options(future.plan = NULL)
[17:29:03.825]                   if (is.na(NA_character_)) 
[17:29:03.825]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:03.825]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:03.825]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:03.825]                     .init = FALSE)
[17:29:03.825]                 }
[17:29:03.825]             }
[17:29:03.825]         }
[17:29:03.825]     })
[17:29:03.825]     if (TRUE) {
[17:29:03.825]         base::sink(type = "output", split = FALSE)
[17:29:03.825]         if (TRUE) {
[17:29:03.825]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:03.825]         }
[17:29:03.825]         else {
[17:29:03.825]             ...future.result["stdout"] <- base::list(NULL)
[17:29:03.825]         }
[17:29:03.825]         base::close(...future.stdout)
[17:29:03.825]         ...future.stdout <- NULL
[17:29:03.825]     }
[17:29:03.825]     ...future.result$conditions <- ...future.conditions
[17:29:03.825]     ...future.result$finished <- base::Sys.time()
[17:29:03.825]     ...future.result
[17:29:03.825] }
[17:29:03.832] plan(): Setting new future strategy stack:
[17:29:03.832] List of future strategies:
[17:29:03.832] 1. sequential:
[17:29:03.832]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:03.832]    - tweaked: FALSE
[17:29:03.832]    - call: NULL
[17:29:03.833] plan(): nbrOfWorkers() = 1
[17:29:03.835] plan(): Setting new future strategy stack:
[17:29:03.836] List of future strategies:
[17:29:03.836] 1. sequential:
[17:29:03.836]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:03.836]    - tweaked: FALSE
[17:29:03.836]    - call: plan(strategy)
[17:29:03.837] plan(): nbrOfWorkers() = 1
[17:29:03.837] SequentialFuture started (and completed)
[17:29:03.838] - Launch lazy future ... done
[17:29:03.838] run() for 'SequentialFuture' ... done
[17:29:03.838] resolved() for 'SequentialFuture' ...
[17:29:03.839] - state: 'finished'
[17:29:03.839] - run: TRUE
[17:29:03.839] - result: 'FutureResult'
[17:29:03.840] resolved() for 'SequentialFuture' ... done
[17:29:03.840] Future #2
[17:29:03.840]  length: 1 (resolved future 2)
[17:29:03.841]  length: 0 (resolved future 3)
[17:29:03.841] resolve() on list ... DONE
[17:29:03.841] resolved() for 'SequentialFuture' ...
[17:29:03.842] - state: 'finished'
[17:29:03.842] - run: TRUE
[17:29:03.842] - result: 'FutureResult'
[17:29:03.843] resolved() for 'SequentialFuture' ... done
[17:29:03.843] resolved() for 'SequentialFuture' ...
[17:29:03.843] - state: 'finished'
[17:29:03.844] - run: TRUE
[17:29:03.844] - result: 'FutureResult'
[17:29:03.844] resolved() for 'SequentialFuture' ... done
[17:29:03.845] getGlobalsAndPackages() ...
[17:29:03.845] Searching for globals...
[17:29:03.846] 
[17:29:03.846] Searching for globals ... DONE
[17:29:03.846] - globals: [0] <none>
[17:29:03.847] getGlobalsAndPackages() ... DONE
[17:29:03.847] run() for 'Future' ...
[17:29:03.848] - state: 'created'
[17:29:03.848] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:03.849] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:03.849] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:03.850]   - Field: 'label'
[17:29:03.850]   - Field: 'local'
[17:29:03.853]   - Field: 'owner'
[17:29:03.853]   - Field: 'envir'
[17:29:03.853]   - Field: 'packages'
[17:29:03.853]   - Field: 'gc'
[17:29:03.853]   - Field: 'conditions'
[17:29:03.854]   - Field: 'expr'
[17:29:03.854]   - Field: 'uuid'
[17:29:03.854]   - Field: 'seed'
[17:29:03.854]   - Field: 'version'
[17:29:03.854]   - Field: 'result'
[17:29:03.855]   - Field: 'asynchronous'
[17:29:03.855]   - Field: 'calls'
[17:29:03.855]   - Field: 'globals'
[17:29:03.855]   - Field: 'stdout'
[17:29:03.855]   - Field: 'earlySignal'
[17:29:03.855]   - Field: 'lazy'
[17:29:03.856]   - Field: 'state'
[17:29:03.856] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:03.856] - Launch lazy future ...
[17:29:03.856] Packages needed by the future expression (n = 0): <none>
[17:29:03.856] Packages needed by future strategies (n = 0): <none>
[17:29:03.857] {
[17:29:03.857]     {
[17:29:03.857]         {
[17:29:03.857]             ...future.startTime <- base::Sys.time()
[17:29:03.857]             {
[17:29:03.857]                 {
[17:29:03.857]                   {
[17:29:03.857]                     base::local({
[17:29:03.857]                       has_future <- base::requireNamespace("future", 
[17:29:03.857]                         quietly = TRUE)
[17:29:03.857]                       if (has_future) {
[17:29:03.857]                         ns <- base::getNamespace("future")
[17:29:03.857]                         version <- ns[[".package"]][["version"]]
[17:29:03.857]                         if (is.null(version)) 
[17:29:03.857]                           version <- utils::packageVersion("future")
[17:29:03.857]                       }
[17:29:03.857]                       else {
[17:29:03.857]                         version <- NULL
[17:29:03.857]                       }
[17:29:03.857]                       if (!has_future || version < "1.8.0") {
[17:29:03.857]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:03.857]                           "", base::R.version$version.string), 
[17:29:03.857]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:03.857]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:03.857]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:03.857]                             "release", "version")], collapse = " "), 
[17:29:03.857]                           hostname = base::Sys.info()[["nodename"]])
[17:29:03.857]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:03.857]                           info)
[17:29:03.857]                         info <- base::paste(info, collapse = "; ")
[17:29:03.857]                         if (!has_future) {
[17:29:03.857]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:03.857]                             info)
[17:29:03.857]                         }
[17:29:03.857]                         else {
[17:29:03.857]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:03.857]                             info, version)
[17:29:03.857]                         }
[17:29:03.857]                         base::stop(msg)
[17:29:03.857]                       }
[17:29:03.857]                     })
[17:29:03.857]                   }
[17:29:03.857]                   ...future.strategy.old <- future::plan("list")
[17:29:03.857]                   options(future.plan = NULL)
[17:29:03.857]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:03.857]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:03.857]                 }
[17:29:03.857]                 ...future.workdir <- getwd()
[17:29:03.857]             }
[17:29:03.857]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:03.857]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:03.857]         }
[17:29:03.857]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:03.857]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:03.857]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:03.857]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:03.857]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:03.857]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:03.857]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:03.857]             base::names(...future.oldOptions))
[17:29:03.857]     }
[17:29:03.857]     if (FALSE) {
[17:29:03.857]     }
[17:29:03.857]     else {
[17:29:03.857]         if (TRUE) {
[17:29:03.857]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:03.857]                 open = "w")
[17:29:03.857]         }
[17:29:03.857]         else {
[17:29:03.857]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:03.857]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:03.857]         }
[17:29:03.857]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:03.857]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:03.857]             base::sink(type = "output", split = FALSE)
[17:29:03.857]             base::close(...future.stdout)
[17:29:03.857]         }, add = TRUE)
[17:29:03.857]     }
[17:29:03.857]     ...future.frame <- base::sys.nframe()
[17:29:03.857]     ...future.conditions <- base::list()
[17:29:03.857]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:03.857]     if (FALSE) {
[17:29:03.857]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:03.857]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:03.857]     }
[17:29:03.857]     ...future.result <- base::tryCatch({
[17:29:03.857]         base::withCallingHandlers({
[17:29:03.857]             ...future.value <- base::withVisible(base::local(1))
[17:29:03.857]             future::FutureResult(value = ...future.value$value, 
[17:29:03.857]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:03.857]                   ...future.rng), globalenv = if (FALSE) 
[17:29:03.857]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:03.857]                     ...future.globalenv.names))
[17:29:03.857]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:03.857]         }, condition = base::local({
[17:29:03.857]             c <- base::c
[17:29:03.857]             inherits <- base::inherits
[17:29:03.857]             invokeRestart <- base::invokeRestart
[17:29:03.857]             length <- base::length
[17:29:03.857]             list <- base::list
[17:29:03.857]             seq.int <- base::seq.int
[17:29:03.857]             signalCondition <- base::signalCondition
[17:29:03.857]             sys.calls <- base::sys.calls
[17:29:03.857]             `[[` <- base::`[[`
[17:29:03.857]             `+` <- base::`+`
[17:29:03.857]             `<<-` <- base::`<<-`
[17:29:03.857]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:03.857]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:03.857]                   3L)]
[17:29:03.857]             }
[17:29:03.857]             function(cond) {
[17:29:03.857]                 is_error <- inherits(cond, "error")
[17:29:03.857]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:03.857]                   NULL)
[17:29:03.857]                 if (is_error) {
[17:29:03.857]                   sessionInformation <- function() {
[17:29:03.857]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:03.857]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:03.857]                       search = base::search(), system = base::Sys.info())
[17:29:03.857]                   }
[17:29:03.857]                   ...future.conditions[[length(...future.conditions) + 
[17:29:03.857]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:03.857]                     cond$call), session = sessionInformation(), 
[17:29:03.857]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:03.857]                   signalCondition(cond)
[17:29:03.857]                 }
[17:29:03.857]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:03.857]                 "immediateCondition"))) {
[17:29:03.857]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:03.857]                   ...future.conditions[[length(...future.conditions) + 
[17:29:03.857]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:03.857]                   if (TRUE && !signal) {
[17:29:03.857]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:03.857]                     {
[17:29:03.857]                       inherits <- base::inherits
[17:29:03.857]                       invokeRestart <- base::invokeRestart
[17:29:03.857]                       is.null <- base::is.null
[17:29:03.857]                       muffled <- FALSE
[17:29:03.857]                       if (inherits(cond, "message")) {
[17:29:03.857]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:03.857]                         if (muffled) 
[17:29:03.857]                           invokeRestart("muffleMessage")
[17:29:03.857]                       }
[17:29:03.857]                       else if (inherits(cond, "warning")) {
[17:29:03.857]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:03.857]                         if (muffled) 
[17:29:03.857]                           invokeRestart("muffleWarning")
[17:29:03.857]                       }
[17:29:03.857]                       else if (inherits(cond, "condition")) {
[17:29:03.857]                         if (!is.null(pattern)) {
[17:29:03.857]                           computeRestarts <- base::computeRestarts
[17:29:03.857]                           grepl <- base::grepl
[17:29:03.857]                           restarts <- computeRestarts(cond)
[17:29:03.857]                           for (restart in restarts) {
[17:29:03.857]                             name <- restart$name
[17:29:03.857]                             if (is.null(name)) 
[17:29:03.857]                               next
[17:29:03.857]                             if (!grepl(pattern, name)) 
[17:29:03.857]                               next
[17:29:03.857]                             invokeRestart(restart)
[17:29:03.857]                             muffled <- TRUE
[17:29:03.857]                             break
[17:29:03.857]                           }
[17:29:03.857]                         }
[17:29:03.857]                       }
[17:29:03.857]                       invisible(muffled)
[17:29:03.857]                     }
[17:29:03.857]                     muffleCondition(cond, pattern = "^muffle")
[17:29:03.857]                   }
[17:29:03.857]                 }
[17:29:03.857]                 else {
[17:29:03.857]                   if (TRUE) {
[17:29:03.857]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:03.857]                     {
[17:29:03.857]                       inherits <- base::inherits
[17:29:03.857]                       invokeRestart <- base::invokeRestart
[17:29:03.857]                       is.null <- base::is.null
[17:29:03.857]                       muffled <- FALSE
[17:29:03.857]                       if (inherits(cond, "message")) {
[17:29:03.857]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:03.857]                         if (muffled) 
[17:29:03.857]                           invokeRestart("muffleMessage")
[17:29:03.857]                       }
[17:29:03.857]                       else if (inherits(cond, "warning")) {
[17:29:03.857]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:03.857]                         if (muffled) 
[17:29:03.857]                           invokeRestart("muffleWarning")
[17:29:03.857]                       }
[17:29:03.857]                       else if (inherits(cond, "condition")) {
[17:29:03.857]                         if (!is.null(pattern)) {
[17:29:03.857]                           computeRestarts <- base::computeRestarts
[17:29:03.857]                           grepl <- base::grepl
[17:29:03.857]                           restarts <- computeRestarts(cond)
[17:29:03.857]                           for (restart in restarts) {
[17:29:03.857]                             name <- restart$name
[17:29:03.857]                             if (is.null(name)) 
[17:29:03.857]                               next
[17:29:03.857]                             if (!grepl(pattern, name)) 
[17:29:03.857]                               next
[17:29:03.857]                             invokeRestart(restart)
[17:29:03.857]                             muffled <- TRUE
[17:29:03.857]                             break
[17:29:03.857]                           }
[17:29:03.857]                         }
[17:29:03.857]                       }
[17:29:03.857]                       invisible(muffled)
[17:29:03.857]                     }
[17:29:03.857]                     muffleCondition(cond, pattern = "^muffle")
[17:29:03.857]                   }
[17:29:03.857]                 }
[17:29:03.857]             }
[17:29:03.857]         }))
[17:29:03.857]     }, error = function(ex) {
[17:29:03.857]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:03.857]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:03.857]                 ...future.rng), started = ...future.startTime, 
[17:29:03.857]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:03.857]             version = "1.8"), class = "FutureResult")
[17:29:03.857]     }, finally = {
[17:29:03.857]         if (!identical(...future.workdir, getwd())) 
[17:29:03.857]             setwd(...future.workdir)
[17:29:03.857]         {
[17:29:03.857]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:03.857]                 ...future.oldOptions$nwarnings <- NULL
[17:29:03.857]             }
[17:29:03.857]             base::options(...future.oldOptions)
[17:29:03.857]             if (.Platform$OS.type == "windows") {
[17:29:03.857]                 old_names <- names(...future.oldEnvVars)
[17:29:03.857]                 envs <- base::Sys.getenv()
[17:29:03.857]                 names <- names(envs)
[17:29:03.857]                 common <- intersect(names, old_names)
[17:29:03.857]                 added <- setdiff(names, old_names)
[17:29:03.857]                 removed <- setdiff(old_names, names)
[17:29:03.857]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:03.857]                   envs[common]]
[17:29:03.857]                 NAMES <- toupper(changed)
[17:29:03.857]                 args <- list()
[17:29:03.857]                 for (kk in seq_along(NAMES)) {
[17:29:03.857]                   name <- changed[[kk]]
[17:29:03.857]                   NAME <- NAMES[[kk]]
[17:29:03.857]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:03.857]                     next
[17:29:03.857]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:03.857]                 }
[17:29:03.857]                 NAMES <- toupper(added)
[17:29:03.857]                 for (kk in seq_along(NAMES)) {
[17:29:03.857]                   name <- added[[kk]]
[17:29:03.857]                   NAME <- NAMES[[kk]]
[17:29:03.857]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:03.857]                     next
[17:29:03.857]                   args[[name]] <- ""
[17:29:03.857]                 }
[17:29:03.857]                 NAMES <- toupper(removed)
[17:29:03.857]                 for (kk in seq_along(NAMES)) {
[17:29:03.857]                   name <- removed[[kk]]
[17:29:03.857]                   NAME <- NAMES[[kk]]
[17:29:03.857]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:03.857]                     next
[17:29:03.857]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:03.857]                 }
[17:29:03.857]                 if (length(args) > 0) 
[17:29:03.857]                   base::do.call(base::Sys.setenv, args = args)
[17:29:03.857]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:03.857]             }
[17:29:03.857]             else {
[17:29:03.857]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:03.857]             }
[17:29:03.857]             {
[17:29:03.857]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:03.857]                   0L) {
[17:29:03.857]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:03.857]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:03.857]                   base::options(opts)
[17:29:03.857]                 }
[17:29:03.857]                 {
[17:29:03.857]                   {
[17:29:03.857]                     NULL
[17:29:03.857]                     RNGkind("Mersenne-Twister")
[17:29:03.857]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:03.857]                       inherits = FALSE)
[17:29:03.857]                   }
[17:29:03.857]                   options(future.plan = NULL)
[17:29:03.857]                   if (is.na(NA_character_)) 
[17:29:03.857]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:03.857]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:03.857]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:03.857]                     .init = FALSE)
[17:29:03.857]                 }
[17:29:03.857]             }
[17:29:03.857]         }
[17:29:03.857]     })
[17:29:03.857]     if (TRUE) {
[17:29:03.857]         base::sink(type = "output", split = FALSE)
[17:29:03.857]         if (TRUE) {
[17:29:03.857]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:03.857]         }
[17:29:03.857]         else {
[17:29:03.857]             ...future.result["stdout"] <- base::list(NULL)
[17:29:03.857]         }
[17:29:03.857]         base::close(...future.stdout)
[17:29:03.857]         ...future.stdout <- NULL
[17:29:03.857]     }
[17:29:03.857]     ...future.result$conditions <- ...future.conditions
[17:29:03.857]     ...future.result$finished <- base::Sys.time()
[17:29:03.857]     ...future.result
[17:29:03.857] }
[17:29:03.862] plan(): Setting new future strategy stack:
[17:29:03.863] List of future strategies:
[17:29:03.863] 1. sequential:
[17:29:03.863]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:03.863]    - tweaked: FALSE
[17:29:03.863]    - call: NULL
[17:29:03.864] plan(): nbrOfWorkers() = 1
[17:29:03.866] plan(): Setting new future strategy stack:
[17:29:03.866] List of future strategies:
[17:29:03.866] 1. sequential:
[17:29:03.866]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:03.866]    - tweaked: FALSE
[17:29:03.866]    - call: plan(strategy)
[17:29:03.867] plan(): nbrOfWorkers() = 1
[17:29:03.867] SequentialFuture started (and completed)
[17:29:03.868] - Launch lazy future ... done
[17:29:03.868] run() for 'SequentialFuture' ... done
[17:29:03.869] getGlobalsAndPackages() ...
[17:29:03.869] Searching for globals...
[17:29:03.878] - globals found: [2] '{', 'Sys.sleep'
[17:29:03.878] Searching for globals ... DONE
[17:29:03.878] Resolving globals: FALSE
[17:29:03.879] 
[17:29:03.880] 
[17:29:03.880] getGlobalsAndPackages() ... DONE
[17:29:03.880] run() for 'Future' ...
[17:29:03.881] - state: 'created'
[17:29:03.881] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:03.882] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:03.882] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:03.882]   - Field: 'label'
[17:29:03.883]   - Field: 'local'
[17:29:03.883]   - Field: 'owner'
[17:29:03.883]   - Field: 'envir'
[17:29:03.884]   - Field: 'packages'
[17:29:03.884]   - Field: 'gc'
[17:29:03.884]   - Field: 'conditions'
[17:29:03.885]   - Field: 'expr'
[17:29:03.885]   - Field: 'uuid'
[17:29:03.885]   - Field: 'seed'
[17:29:03.886]   - Field: 'version'
[17:29:03.886]   - Field: 'result'
[17:29:03.886]   - Field: 'asynchronous'
[17:29:03.887]   - Field: 'calls'
[17:29:03.887]   - Field: 'globals'
[17:29:03.887]   - Field: 'stdout'
[17:29:03.888]   - Field: 'earlySignal'
[17:29:03.888]   - Field: 'lazy'
[17:29:03.888]   - Field: 'state'
[17:29:03.889] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:03.889] - Launch lazy future ...
[17:29:03.889] Packages needed by the future expression (n = 0): <none>
[17:29:03.890] Packages needed by future strategies (n = 0): <none>
[17:29:03.891] {
[17:29:03.891]     {
[17:29:03.891]         {
[17:29:03.891]             ...future.startTime <- base::Sys.time()
[17:29:03.891]             {
[17:29:03.891]                 {
[17:29:03.891]                   {
[17:29:03.891]                     base::local({
[17:29:03.891]                       has_future <- base::requireNamespace("future", 
[17:29:03.891]                         quietly = TRUE)
[17:29:03.891]                       if (has_future) {
[17:29:03.891]                         ns <- base::getNamespace("future")
[17:29:03.891]                         version <- ns[[".package"]][["version"]]
[17:29:03.891]                         if (is.null(version)) 
[17:29:03.891]                           version <- utils::packageVersion("future")
[17:29:03.891]                       }
[17:29:03.891]                       else {
[17:29:03.891]                         version <- NULL
[17:29:03.891]                       }
[17:29:03.891]                       if (!has_future || version < "1.8.0") {
[17:29:03.891]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:03.891]                           "", base::R.version$version.string), 
[17:29:03.891]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:03.891]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:03.891]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:03.891]                             "release", "version")], collapse = " "), 
[17:29:03.891]                           hostname = base::Sys.info()[["nodename"]])
[17:29:03.891]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:03.891]                           info)
[17:29:03.891]                         info <- base::paste(info, collapse = "; ")
[17:29:03.891]                         if (!has_future) {
[17:29:03.891]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:03.891]                             info)
[17:29:03.891]                         }
[17:29:03.891]                         else {
[17:29:03.891]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:03.891]                             info, version)
[17:29:03.891]                         }
[17:29:03.891]                         base::stop(msg)
[17:29:03.891]                       }
[17:29:03.891]                     })
[17:29:03.891]                   }
[17:29:03.891]                   ...future.strategy.old <- future::plan("list")
[17:29:03.891]                   options(future.plan = NULL)
[17:29:03.891]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:03.891]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:03.891]                 }
[17:29:03.891]                 ...future.workdir <- getwd()
[17:29:03.891]             }
[17:29:03.891]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:03.891]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:03.891]         }
[17:29:03.891]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:03.891]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:03.891]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:03.891]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:03.891]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:03.891]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:03.891]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:03.891]             base::names(...future.oldOptions))
[17:29:03.891]     }
[17:29:03.891]     if (FALSE) {
[17:29:03.891]     }
[17:29:03.891]     else {
[17:29:03.891]         if (TRUE) {
[17:29:03.891]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:03.891]                 open = "w")
[17:29:03.891]         }
[17:29:03.891]         else {
[17:29:03.891]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:03.891]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:03.891]         }
[17:29:03.891]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:03.891]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:03.891]             base::sink(type = "output", split = FALSE)
[17:29:03.891]             base::close(...future.stdout)
[17:29:03.891]         }, add = TRUE)
[17:29:03.891]     }
[17:29:03.891]     ...future.frame <- base::sys.nframe()
[17:29:03.891]     ...future.conditions <- base::list()
[17:29:03.891]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:03.891]     if (FALSE) {
[17:29:03.891]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:03.891]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:03.891]     }
[17:29:03.891]     ...future.result <- base::tryCatch({
[17:29:03.891]         base::withCallingHandlers({
[17:29:03.891]             ...future.value <- base::withVisible(base::local({
[17:29:03.891]                 Sys.sleep(0.5)
[17:29:03.891]                 2
[17:29:03.891]             }))
[17:29:03.891]             future::FutureResult(value = ...future.value$value, 
[17:29:03.891]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:03.891]                   ...future.rng), globalenv = if (FALSE) 
[17:29:03.891]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:03.891]                     ...future.globalenv.names))
[17:29:03.891]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:03.891]         }, condition = base::local({
[17:29:03.891]             c <- base::c
[17:29:03.891]             inherits <- base::inherits
[17:29:03.891]             invokeRestart <- base::invokeRestart
[17:29:03.891]             length <- base::length
[17:29:03.891]             list <- base::list
[17:29:03.891]             seq.int <- base::seq.int
[17:29:03.891]             signalCondition <- base::signalCondition
[17:29:03.891]             sys.calls <- base::sys.calls
[17:29:03.891]             `[[` <- base::`[[`
[17:29:03.891]             `+` <- base::`+`
[17:29:03.891]             `<<-` <- base::`<<-`
[17:29:03.891]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:03.891]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:03.891]                   3L)]
[17:29:03.891]             }
[17:29:03.891]             function(cond) {
[17:29:03.891]                 is_error <- inherits(cond, "error")
[17:29:03.891]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:03.891]                   NULL)
[17:29:03.891]                 if (is_error) {
[17:29:03.891]                   sessionInformation <- function() {
[17:29:03.891]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:03.891]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:03.891]                       search = base::search(), system = base::Sys.info())
[17:29:03.891]                   }
[17:29:03.891]                   ...future.conditions[[length(...future.conditions) + 
[17:29:03.891]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:03.891]                     cond$call), session = sessionInformation(), 
[17:29:03.891]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:03.891]                   signalCondition(cond)
[17:29:03.891]                 }
[17:29:03.891]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:03.891]                 "immediateCondition"))) {
[17:29:03.891]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:03.891]                   ...future.conditions[[length(...future.conditions) + 
[17:29:03.891]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:03.891]                   if (TRUE && !signal) {
[17:29:03.891]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:03.891]                     {
[17:29:03.891]                       inherits <- base::inherits
[17:29:03.891]                       invokeRestart <- base::invokeRestart
[17:29:03.891]                       is.null <- base::is.null
[17:29:03.891]                       muffled <- FALSE
[17:29:03.891]                       if (inherits(cond, "message")) {
[17:29:03.891]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:03.891]                         if (muffled) 
[17:29:03.891]                           invokeRestart("muffleMessage")
[17:29:03.891]                       }
[17:29:03.891]                       else if (inherits(cond, "warning")) {
[17:29:03.891]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:03.891]                         if (muffled) 
[17:29:03.891]                           invokeRestart("muffleWarning")
[17:29:03.891]                       }
[17:29:03.891]                       else if (inherits(cond, "condition")) {
[17:29:03.891]                         if (!is.null(pattern)) {
[17:29:03.891]                           computeRestarts <- base::computeRestarts
[17:29:03.891]                           grepl <- base::grepl
[17:29:03.891]                           restarts <- computeRestarts(cond)
[17:29:03.891]                           for (restart in restarts) {
[17:29:03.891]                             name <- restart$name
[17:29:03.891]                             if (is.null(name)) 
[17:29:03.891]                               next
[17:29:03.891]                             if (!grepl(pattern, name)) 
[17:29:03.891]                               next
[17:29:03.891]                             invokeRestart(restart)
[17:29:03.891]                             muffled <- TRUE
[17:29:03.891]                             break
[17:29:03.891]                           }
[17:29:03.891]                         }
[17:29:03.891]                       }
[17:29:03.891]                       invisible(muffled)
[17:29:03.891]                     }
[17:29:03.891]                     muffleCondition(cond, pattern = "^muffle")
[17:29:03.891]                   }
[17:29:03.891]                 }
[17:29:03.891]                 else {
[17:29:03.891]                   if (TRUE) {
[17:29:03.891]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:03.891]                     {
[17:29:03.891]                       inherits <- base::inherits
[17:29:03.891]                       invokeRestart <- base::invokeRestart
[17:29:03.891]                       is.null <- base::is.null
[17:29:03.891]                       muffled <- FALSE
[17:29:03.891]                       if (inherits(cond, "message")) {
[17:29:03.891]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:03.891]                         if (muffled) 
[17:29:03.891]                           invokeRestart("muffleMessage")
[17:29:03.891]                       }
[17:29:03.891]                       else if (inherits(cond, "warning")) {
[17:29:03.891]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:03.891]                         if (muffled) 
[17:29:03.891]                           invokeRestart("muffleWarning")
[17:29:03.891]                       }
[17:29:03.891]                       else if (inherits(cond, "condition")) {
[17:29:03.891]                         if (!is.null(pattern)) {
[17:29:03.891]                           computeRestarts <- base::computeRestarts
[17:29:03.891]                           grepl <- base::grepl
[17:29:03.891]                           restarts <- computeRestarts(cond)
[17:29:03.891]                           for (restart in restarts) {
[17:29:03.891]                             name <- restart$name
[17:29:03.891]                             if (is.null(name)) 
[17:29:03.891]                               next
[17:29:03.891]                             if (!grepl(pattern, name)) 
[17:29:03.891]                               next
[17:29:03.891]                             invokeRestart(restart)
[17:29:03.891]                             muffled <- TRUE
[17:29:03.891]                             break
[17:29:03.891]                           }
[17:29:03.891]                         }
[17:29:03.891]                       }
[17:29:03.891]                       invisible(muffled)
[17:29:03.891]                     }
[17:29:03.891]                     muffleCondition(cond, pattern = "^muffle")
[17:29:03.891]                   }
[17:29:03.891]                 }
[17:29:03.891]             }
[17:29:03.891]         }))
[17:29:03.891]     }, error = function(ex) {
[17:29:03.891]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:03.891]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:03.891]                 ...future.rng), started = ...future.startTime, 
[17:29:03.891]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:03.891]             version = "1.8"), class = "FutureResult")
[17:29:03.891]     }, finally = {
[17:29:03.891]         if (!identical(...future.workdir, getwd())) 
[17:29:03.891]             setwd(...future.workdir)
[17:29:03.891]         {
[17:29:03.891]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:03.891]                 ...future.oldOptions$nwarnings <- NULL
[17:29:03.891]             }
[17:29:03.891]             base::options(...future.oldOptions)
[17:29:03.891]             if (.Platform$OS.type == "windows") {
[17:29:03.891]                 old_names <- names(...future.oldEnvVars)
[17:29:03.891]                 envs <- base::Sys.getenv()
[17:29:03.891]                 names <- names(envs)
[17:29:03.891]                 common <- intersect(names, old_names)
[17:29:03.891]                 added <- setdiff(names, old_names)
[17:29:03.891]                 removed <- setdiff(old_names, names)
[17:29:03.891]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:03.891]                   envs[common]]
[17:29:03.891]                 NAMES <- toupper(changed)
[17:29:03.891]                 args <- list()
[17:29:03.891]                 for (kk in seq_along(NAMES)) {
[17:29:03.891]                   name <- changed[[kk]]
[17:29:03.891]                   NAME <- NAMES[[kk]]
[17:29:03.891]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:03.891]                     next
[17:29:03.891]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:03.891]                 }
[17:29:03.891]                 NAMES <- toupper(added)
[17:29:03.891]                 for (kk in seq_along(NAMES)) {
[17:29:03.891]                   name <- added[[kk]]
[17:29:03.891]                   NAME <- NAMES[[kk]]
[17:29:03.891]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:03.891]                     next
[17:29:03.891]                   args[[name]] <- ""
[17:29:03.891]                 }
[17:29:03.891]                 NAMES <- toupper(removed)
[17:29:03.891]                 for (kk in seq_along(NAMES)) {
[17:29:03.891]                   name <- removed[[kk]]
[17:29:03.891]                   NAME <- NAMES[[kk]]
[17:29:03.891]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:03.891]                     next
[17:29:03.891]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:03.891]                 }
[17:29:03.891]                 if (length(args) > 0) 
[17:29:03.891]                   base::do.call(base::Sys.setenv, args = args)
[17:29:03.891]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:03.891]             }
[17:29:03.891]             else {
[17:29:03.891]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:03.891]             }
[17:29:03.891]             {
[17:29:03.891]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:03.891]                   0L) {
[17:29:03.891]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:03.891]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:03.891]                   base::options(opts)
[17:29:03.891]                 }
[17:29:03.891]                 {
[17:29:03.891]                   {
[17:29:03.891]                     NULL
[17:29:03.891]                     RNGkind("Mersenne-Twister")
[17:29:03.891]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:03.891]                       inherits = FALSE)
[17:29:03.891]                   }
[17:29:03.891]                   options(future.plan = NULL)
[17:29:03.891]                   if (is.na(NA_character_)) 
[17:29:03.891]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:03.891]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:03.891]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:03.891]                     .init = FALSE)
[17:29:03.891]                 }
[17:29:03.891]             }
[17:29:03.891]         }
[17:29:03.891]     })
[17:29:03.891]     if (TRUE) {
[17:29:03.891]         base::sink(type = "output", split = FALSE)
[17:29:03.891]         if (TRUE) {
[17:29:03.891]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:03.891]         }
[17:29:03.891]         else {
[17:29:03.891]             ...future.result["stdout"] <- base::list(NULL)
[17:29:03.891]         }
[17:29:03.891]         base::close(...future.stdout)
[17:29:03.891]         ...future.stdout <- NULL
[17:29:03.891]     }
[17:29:03.891]     ...future.result$conditions <- ...future.conditions
[17:29:03.891]     ...future.result$finished <- base::Sys.time()
[17:29:03.891]     ...future.result
[17:29:03.891] }
[17:29:03.898] plan(): Setting new future strategy stack:
[17:29:03.898] List of future strategies:
[17:29:03.898] 1. sequential:
[17:29:03.898]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:03.898]    - tweaked: FALSE
[17:29:03.898]    - call: NULL
[17:29:03.899] plan(): nbrOfWorkers() = 1
[17:29:04.410] plan(): Setting new future strategy stack:
[17:29:04.411] List of future strategies:
[17:29:04.411] 1. sequential:
[17:29:04.411]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:04.411]    - tweaked: FALSE
[17:29:04.411]    - call: plan(strategy)
[17:29:04.412] plan(): nbrOfWorkers() = 1
[17:29:04.413] SequentialFuture started (and completed)
[17:29:04.413] - Launch lazy future ... done
[17:29:04.414] run() for 'SequentialFuture' ... done
[17:29:04.415] resolve() on list ...
[17:29:04.415]  recursive: 0
[17:29:04.416]  length: 1
[17:29:04.416] 
[17:29:04.416] resolved() for 'SequentialFuture' ...
[17:29:04.417] - state: 'finished'
[17:29:04.417] - run: TRUE
[17:29:04.417] - result: 'FutureResult'
[17:29:04.418] resolved() for 'SequentialFuture' ... done
[17:29:04.418] Future #1
[17:29:04.419]  length: 0 (resolved future 1)
[17:29:04.419] resolve() on list ... DONE
[17:29:04.419] resolved() for 'SequentialFuture' ...
[17:29:04.420] - state: 'finished'
[17:29:04.420] - run: TRUE
[17:29:04.420] - result: 'FutureResult'
[17:29:04.421] resolved() for 'SequentialFuture' ... done
[17:29:04.421] resolve() on list ...
[17:29:04.422]  recursive: 0
[17:29:04.422]  length: 1
[17:29:04.422] 
[17:29:04.423] resolved() for 'SequentialFuture' ...
[17:29:04.423] - state: 'finished'
[17:29:04.423] - run: TRUE
[17:29:04.424] - result: 'FutureResult'
[17:29:04.424] resolved() for 'SequentialFuture' ... done
[17:29:04.424] Future #1
[17:29:04.425]  length: 0 (resolved future 1)
[17:29:04.425] resolve() on list ... DONE
[17:29:04.425] resolved() for 'SequentialFuture' ...
[17:29:04.425] - state: 'finished'
[17:29:04.426] - run: TRUE
[17:29:04.426] - result: 'FutureResult'
[17:29:04.426] resolved() for 'SequentialFuture' ... done
[17:29:04.427] resolve() on list ...
[17:29:04.427]  recursive: 0
[17:29:04.428]  length: 1
[17:29:04.428] 
[17:29:04.432]  length: 0 (resolved future 1)
[17:29:04.432] resolve() on list ... DONE
[17:29:04.433] resolve() on list ...
[17:29:04.434]  recursive: 0
[17:29:04.434]  length: 4
[17:29:04.434] 
[17:29:04.435] resolved() for 'SequentialFuture' ...
[17:29:04.435] - state: 'finished'
[17:29:04.435] - run: TRUE
[17:29:04.436] - result: 'FutureResult'
[17:29:04.436] resolved() for 'SequentialFuture' ... done
[17:29:04.437] Future #1
[17:29:04.437]  length: 3 (resolved future 1)
[17:29:04.437] resolved() for 'SequentialFuture' ...
[17:29:04.438] - state: 'finished'
[17:29:04.438] - run: TRUE
[17:29:04.438] - result: 'FutureResult'
[17:29:04.439] resolved() for 'SequentialFuture' ... done
[17:29:04.439] Future #2
[17:29:04.440]  length: 2 (resolved future 2)
[17:29:04.440]  length: 1 (resolved future 3)
[17:29:04.440]  length: 0 (resolved future 4)
[17:29:04.440] resolve() on list ... DONE
[17:29:04.441] resolve() on list ...
[17:29:04.441]  recursive: 0
[17:29:04.441]  length: 4
[17:29:04.441] 
[17:29:04.441] resolved() for 'SequentialFuture' ...
[17:29:04.442] - state: 'finished'
[17:29:04.442] - run: TRUE
[17:29:04.442] - result: 'FutureResult'
[17:29:04.442] resolved() for 'SequentialFuture' ... done
[17:29:04.442] Future #1
[17:29:04.443]  length: 3 (resolved future 1)
[17:29:04.443] resolved() for 'SequentialFuture' ...
[17:29:04.443] - state: 'finished'
[17:29:04.443] - run: TRUE
[17:29:04.443] - result: 'FutureResult'
[17:29:04.443] resolved() for 'SequentialFuture' ... done
[17:29:04.444] Future #2
[17:29:04.444]  length: 2 (resolved future 2)
[17:29:04.444]  length: 1 (resolved future 3)
[17:29:04.444]  length: 0 (resolved future 4)
[17:29:04.444] resolve() on list ... DONE
[17:29:04.445] resolve() on list ...
[17:29:04.445]  recursive: 0
[17:29:04.445]  length: 1
[17:29:04.445] 
[17:29:04.445]  length: 0 (resolved future 1)
[17:29:04.446] resolve() on list ... DONE
[17:29:04.446] getGlobalsAndPackages() ...
[17:29:04.446] Searching for globals...
[17:29:04.447] - globals found: [3] '{', 'Sys.sleep', 'kk'
[17:29:04.448] Searching for globals ... DONE
[17:29:04.448] Resolving globals: FALSE
[17:29:04.449] The total size of the 1 globals is 35 bytes (35 bytes)
[17:29:04.449] The total size of the 1 globals exported for future expression ('{; Sys.sleep(0.1); kk; }') is 35 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'kk' (35 bytes of class 'numeric')
[17:29:04.450] - globals: [1] 'kk'
[17:29:04.450] 
[17:29:04.450] getGlobalsAndPackages() ... DONE
[17:29:04.450] run() for 'Future' ...
[17:29:04.451] - state: 'created'
[17:29:04.451] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:04.451] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:04.451] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:04.452]   - Field: 'label'
[17:29:04.452]   - Field: 'local'
[17:29:04.452]   - Field: 'owner'
[17:29:04.452]   - Field: 'envir'
[17:29:04.452]   - Field: 'packages'
[17:29:04.452]   - Field: 'gc'
[17:29:04.453]   - Field: 'conditions'
[17:29:04.453]   - Field: 'expr'
[17:29:04.453]   - Field: 'uuid'
[17:29:04.453]   - Field: 'seed'
[17:29:04.453]   - Field: 'version'
[17:29:04.453]   - Field: 'result'
[17:29:04.454]   - Field: 'asynchronous'
[17:29:04.454]   - Field: 'calls'
[17:29:04.454]   - Field: 'globals'
[17:29:04.454]   - Field: 'stdout'
[17:29:04.454]   - Field: 'earlySignal'
[17:29:04.455]   - Field: 'lazy'
[17:29:04.455]   - Field: 'state'
[17:29:04.455] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:04.455] - Launch lazy future ...
[17:29:04.455] Packages needed by the future expression (n = 0): <none>
[17:29:04.456] Packages needed by future strategies (n = 0): <none>
[17:29:04.457] {
[17:29:04.457]     {
[17:29:04.457]         {
[17:29:04.457]             ...future.startTime <- base::Sys.time()
[17:29:04.457]             {
[17:29:04.457]                 {
[17:29:04.457]                   {
[17:29:04.457]                     base::local({
[17:29:04.457]                       has_future <- base::requireNamespace("future", 
[17:29:04.457]                         quietly = TRUE)
[17:29:04.457]                       if (has_future) {
[17:29:04.457]                         ns <- base::getNamespace("future")
[17:29:04.457]                         version <- ns[[".package"]][["version"]]
[17:29:04.457]                         if (is.null(version)) 
[17:29:04.457]                           version <- utils::packageVersion("future")
[17:29:04.457]                       }
[17:29:04.457]                       else {
[17:29:04.457]                         version <- NULL
[17:29:04.457]                       }
[17:29:04.457]                       if (!has_future || version < "1.8.0") {
[17:29:04.457]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:04.457]                           "", base::R.version$version.string), 
[17:29:04.457]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:04.457]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:04.457]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:04.457]                             "release", "version")], collapse = " "), 
[17:29:04.457]                           hostname = base::Sys.info()[["nodename"]])
[17:29:04.457]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:04.457]                           info)
[17:29:04.457]                         info <- base::paste(info, collapse = "; ")
[17:29:04.457]                         if (!has_future) {
[17:29:04.457]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:04.457]                             info)
[17:29:04.457]                         }
[17:29:04.457]                         else {
[17:29:04.457]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:04.457]                             info, version)
[17:29:04.457]                         }
[17:29:04.457]                         base::stop(msg)
[17:29:04.457]                       }
[17:29:04.457]                     })
[17:29:04.457]                   }
[17:29:04.457]                   ...future.strategy.old <- future::plan("list")
[17:29:04.457]                   options(future.plan = NULL)
[17:29:04.457]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:04.457]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:04.457]                 }
[17:29:04.457]                 ...future.workdir <- getwd()
[17:29:04.457]             }
[17:29:04.457]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:04.457]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:04.457]         }
[17:29:04.457]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:04.457]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:04.457]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:04.457]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:04.457]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:04.457]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:04.457]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:04.457]             base::names(...future.oldOptions))
[17:29:04.457]     }
[17:29:04.457]     if (FALSE) {
[17:29:04.457]     }
[17:29:04.457]     else {
[17:29:04.457]         if (TRUE) {
[17:29:04.457]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:04.457]                 open = "w")
[17:29:04.457]         }
[17:29:04.457]         else {
[17:29:04.457]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:04.457]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:04.457]         }
[17:29:04.457]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:04.457]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:04.457]             base::sink(type = "output", split = FALSE)
[17:29:04.457]             base::close(...future.stdout)
[17:29:04.457]         }, add = TRUE)
[17:29:04.457]     }
[17:29:04.457]     ...future.frame <- base::sys.nframe()
[17:29:04.457]     ...future.conditions <- base::list()
[17:29:04.457]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:04.457]     if (FALSE) {
[17:29:04.457]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:04.457]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:04.457]     }
[17:29:04.457]     ...future.result <- base::tryCatch({
[17:29:04.457]         base::withCallingHandlers({
[17:29:04.457]             ...future.value <- base::withVisible(base::local({
[17:29:04.457]                 Sys.sleep(0.1)
[17:29:04.457]                 kk
[17:29:04.457]             }))
[17:29:04.457]             future::FutureResult(value = ...future.value$value, 
[17:29:04.457]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:04.457]                   ...future.rng), globalenv = if (FALSE) 
[17:29:04.457]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:04.457]                     ...future.globalenv.names))
[17:29:04.457]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:04.457]         }, condition = base::local({
[17:29:04.457]             c <- base::c
[17:29:04.457]             inherits <- base::inherits
[17:29:04.457]             invokeRestart <- base::invokeRestart
[17:29:04.457]             length <- base::length
[17:29:04.457]             list <- base::list
[17:29:04.457]             seq.int <- base::seq.int
[17:29:04.457]             signalCondition <- base::signalCondition
[17:29:04.457]             sys.calls <- base::sys.calls
[17:29:04.457]             `[[` <- base::`[[`
[17:29:04.457]             `+` <- base::`+`
[17:29:04.457]             `<<-` <- base::`<<-`
[17:29:04.457]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:04.457]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:04.457]                   3L)]
[17:29:04.457]             }
[17:29:04.457]             function(cond) {
[17:29:04.457]                 is_error <- inherits(cond, "error")
[17:29:04.457]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:04.457]                   NULL)
[17:29:04.457]                 if (is_error) {
[17:29:04.457]                   sessionInformation <- function() {
[17:29:04.457]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:04.457]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:04.457]                       search = base::search(), system = base::Sys.info())
[17:29:04.457]                   }
[17:29:04.457]                   ...future.conditions[[length(...future.conditions) + 
[17:29:04.457]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:04.457]                     cond$call), session = sessionInformation(), 
[17:29:04.457]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:04.457]                   signalCondition(cond)
[17:29:04.457]                 }
[17:29:04.457]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:04.457]                 "immediateCondition"))) {
[17:29:04.457]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:04.457]                   ...future.conditions[[length(...future.conditions) + 
[17:29:04.457]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:04.457]                   if (TRUE && !signal) {
[17:29:04.457]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:04.457]                     {
[17:29:04.457]                       inherits <- base::inherits
[17:29:04.457]                       invokeRestart <- base::invokeRestart
[17:29:04.457]                       is.null <- base::is.null
[17:29:04.457]                       muffled <- FALSE
[17:29:04.457]                       if (inherits(cond, "message")) {
[17:29:04.457]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:04.457]                         if (muffled) 
[17:29:04.457]                           invokeRestart("muffleMessage")
[17:29:04.457]                       }
[17:29:04.457]                       else if (inherits(cond, "warning")) {
[17:29:04.457]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:04.457]                         if (muffled) 
[17:29:04.457]                           invokeRestart("muffleWarning")
[17:29:04.457]                       }
[17:29:04.457]                       else if (inherits(cond, "condition")) {
[17:29:04.457]                         if (!is.null(pattern)) {
[17:29:04.457]                           computeRestarts <- base::computeRestarts
[17:29:04.457]                           grepl <- base::grepl
[17:29:04.457]                           restarts <- computeRestarts(cond)
[17:29:04.457]                           for (restart in restarts) {
[17:29:04.457]                             name <- restart$name
[17:29:04.457]                             if (is.null(name)) 
[17:29:04.457]                               next
[17:29:04.457]                             if (!grepl(pattern, name)) 
[17:29:04.457]                               next
[17:29:04.457]                             invokeRestart(restart)
[17:29:04.457]                             muffled <- TRUE
[17:29:04.457]                             break
[17:29:04.457]                           }
[17:29:04.457]                         }
[17:29:04.457]                       }
[17:29:04.457]                       invisible(muffled)
[17:29:04.457]                     }
[17:29:04.457]                     muffleCondition(cond, pattern = "^muffle")
[17:29:04.457]                   }
[17:29:04.457]                 }
[17:29:04.457]                 else {
[17:29:04.457]                   if (TRUE) {
[17:29:04.457]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:04.457]                     {
[17:29:04.457]                       inherits <- base::inherits
[17:29:04.457]                       invokeRestart <- base::invokeRestart
[17:29:04.457]                       is.null <- base::is.null
[17:29:04.457]                       muffled <- FALSE
[17:29:04.457]                       if (inherits(cond, "message")) {
[17:29:04.457]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:04.457]                         if (muffled) 
[17:29:04.457]                           invokeRestart("muffleMessage")
[17:29:04.457]                       }
[17:29:04.457]                       else if (inherits(cond, "warning")) {
[17:29:04.457]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:04.457]                         if (muffled) 
[17:29:04.457]                           invokeRestart("muffleWarning")
[17:29:04.457]                       }
[17:29:04.457]                       else if (inherits(cond, "condition")) {
[17:29:04.457]                         if (!is.null(pattern)) {
[17:29:04.457]                           computeRestarts <- base::computeRestarts
[17:29:04.457]                           grepl <- base::grepl
[17:29:04.457]                           restarts <- computeRestarts(cond)
[17:29:04.457]                           for (restart in restarts) {
[17:29:04.457]                             name <- restart$name
[17:29:04.457]                             if (is.null(name)) 
[17:29:04.457]                               next
[17:29:04.457]                             if (!grepl(pattern, name)) 
[17:29:04.457]                               next
[17:29:04.457]                             invokeRestart(restart)
[17:29:04.457]                             muffled <- TRUE
[17:29:04.457]                             break
[17:29:04.457]                           }
[17:29:04.457]                         }
[17:29:04.457]                       }
[17:29:04.457]                       invisible(muffled)
[17:29:04.457]                     }
[17:29:04.457]                     muffleCondition(cond, pattern = "^muffle")
[17:29:04.457]                   }
[17:29:04.457]                 }
[17:29:04.457]             }
[17:29:04.457]         }))
[17:29:04.457]     }, error = function(ex) {
[17:29:04.457]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:04.457]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:04.457]                 ...future.rng), started = ...future.startTime, 
[17:29:04.457]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:04.457]             version = "1.8"), class = "FutureResult")
[17:29:04.457]     }, finally = {
[17:29:04.457]         if (!identical(...future.workdir, getwd())) 
[17:29:04.457]             setwd(...future.workdir)
[17:29:04.457]         {
[17:29:04.457]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:04.457]                 ...future.oldOptions$nwarnings <- NULL
[17:29:04.457]             }
[17:29:04.457]             base::options(...future.oldOptions)
[17:29:04.457]             if (.Platform$OS.type == "windows") {
[17:29:04.457]                 old_names <- names(...future.oldEnvVars)
[17:29:04.457]                 envs <- base::Sys.getenv()
[17:29:04.457]                 names <- names(envs)
[17:29:04.457]                 common <- intersect(names, old_names)
[17:29:04.457]                 added <- setdiff(names, old_names)
[17:29:04.457]                 removed <- setdiff(old_names, names)
[17:29:04.457]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:04.457]                   envs[common]]
[17:29:04.457]                 NAMES <- toupper(changed)
[17:29:04.457]                 args <- list()
[17:29:04.457]                 for (kk in seq_along(NAMES)) {
[17:29:04.457]                   name <- changed[[kk]]
[17:29:04.457]                   NAME <- NAMES[[kk]]
[17:29:04.457]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:04.457]                     next
[17:29:04.457]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:04.457]                 }
[17:29:04.457]                 NAMES <- toupper(added)
[17:29:04.457]                 for (kk in seq_along(NAMES)) {
[17:29:04.457]                   name <- added[[kk]]
[17:29:04.457]                   NAME <- NAMES[[kk]]
[17:29:04.457]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:04.457]                     next
[17:29:04.457]                   args[[name]] <- ""
[17:29:04.457]                 }
[17:29:04.457]                 NAMES <- toupper(removed)
[17:29:04.457]                 for (kk in seq_along(NAMES)) {
[17:29:04.457]                   name <- removed[[kk]]
[17:29:04.457]                   NAME <- NAMES[[kk]]
[17:29:04.457]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:04.457]                     next
[17:29:04.457]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:04.457]                 }
[17:29:04.457]                 if (length(args) > 0) 
[17:29:04.457]                   base::do.call(base::Sys.setenv, args = args)
[17:29:04.457]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:04.457]             }
[17:29:04.457]             else {
[17:29:04.457]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:04.457]             }
[17:29:04.457]             {
[17:29:04.457]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:04.457]                   0L) {
[17:29:04.457]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:04.457]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:04.457]                   base::options(opts)
[17:29:04.457]                 }
[17:29:04.457]                 {
[17:29:04.457]                   {
[17:29:04.457]                     NULL
[17:29:04.457]                     RNGkind("Mersenne-Twister")
[17:29:04.457]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:04.457]                       inherits = FALSE)
[17:29:04.457]                   }
[17:29:04.457]                   options(future.plan = NULL)
[17:29:04.457]                   if (is.na(NA_character_)) 
[17:29:04.457]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:04.457]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:04.457]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:04.457]                     .init = FALSE)
[17:29:04.457]                 }
[17:29:04.457]             }
[17:29:04.457]         }
[17:29:04.457]     })
[17:29:04.457]     if (TRUE) {
[17:29:04.457]         base::sink(type = "output", split = FALSE)
[17:29:04.457]         if (TRUE) {
[17:29:04.457]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:04.457]         }
[17:29:04.457]         else {
[17:29:04.457]             ...future.result["stdout"] <- base::list(NULL)
[17:29:04.457]         }
[17:29:04.457]         base::close(...future.stdout)
[17:29:04.457]         ...future.stdout <- NULL
[17:29:04.457]     }
[17:29:04.457]     ...future.result$conditions <- ...future.conditions
[17:29:04.457]     ...future.result$finished <- base::Sys.time()
[17:29:04.457]     ...future.result
[17:29:04.457] }
[17:29:04.464] assign_globals() ...
[17:29:04.464] List of 1
[17:29:04.464]  $ kk: int 1
[17:29:04.464]  - attr(*, "where")=List of 1
[17:29:04.464]   ..$ kk:<environment: R_EmptyEnv> 
[17:29:04.464]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:04.464]  - attr(*, "resolved")= logi FALSE
[17:29:04.464]  - attr(*, "total_size")= int 35
[17:29:04.464]  - attr(*, "already-done")= logi TRUE
[17:29:04.474] - copied 'kk' to environment
[17:29:04.474] assign_globals() ... done
[17:29:04.475] plan(): Setting new future strategy stack:
[17:29:04.475] List of future strategies:
[17:29:04.475] 1. sequential:
[17:29:04.475]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:04.475]    - tweaked: FALSE
[17:29:04.475]    - call: NULL
[17:29:04.476] plan(): nbrOfWorkers() = 1
[17:29:04.582] plan(): Setting new future strategy stack:
[17:29:04.582] List of future strategies:
[17:29:04.582] 1. sequential:
[17:29:04.582]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:04.582]    - tweaked: FALSE
[17:29:04.582]    - call: plan(strategy)
[17:29:04.584] plan(): nbrOfWorkers() = 1
[17:29:04.584] SequentialFuture started (and completed)
[17:29:04.585] - Launch lazy future ... done
[17:29:04.585] run() for 'SequentialFuture' ... done
[17:29:04.585] getGlobalsAndPackages() ...
[17:29:04.586] Searching for globals...
[17:29:04.591] - globals found: [3] '{', 'Sys.sleep', 'kk'
[17:29:04.592] Searching for globals ... DONE
[17:29:04.592] Resolving globals: FALSE
[17:29:04.593] The total size of the 1 globals is 35 bytes (35 bytes)
[17:29:04.594] The total size of the 1 globals exported for future expression ('{; Sys.sleep(0.1); kk; }') is 35 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'kk' (35 bytes of class 'numeric')
[17:29:04.594] - globals: [1] 'kk'
[17:29:04.594] 
[17:29:04.595] getGlobalsAndPackages() ... DONE
[17:29:04.595] run() for 'Future' ...
[17:29:04.595] - state: 'created'
[17:29:04.596] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:04.597] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:04.597] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:04.597]   - Field: 'label'
[17:29:04.598]   - Field: 'local'
[17:29:04.598]   - Field: 'owner'
[17:29:04.598]   - Field: 'envir'
[17:29:04.598]   - Field: 'packages'
[17:29:04.599]   - Field: 'gc'
[17:29:04.599]   - Field: 'conditions'
[17:29:04.599]   - Field: 'expr'
[17:29:04.600]   - Field: 'uuid'
[17:29:04.600]   - Field: 'seed'
[17:29:04.600]   - Field: 'version'
[17:29:04.601]   - Field: 'result'
[17:29:04.601]   - Field: 'asynchronous'
[17:29:04.601]   - Field: 'calls'
[17:29:04.602]   - Field: 'globals'
[17:29:04.602]   - Field: 'stdout'
[17:29:04.602]   - Field: 'earlySignal'
[17:29:04.603]   - Field: 'lazy'
[17:29:04.603]   - Field: 'state'
[17:29:04.603] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:04.603] - Launch lazy future ...
[17:29:04.604] Packages needed by the future expression (n = 0): <none>
[17:29:04.604] Packages needed by future strategies (n = 0): <none>
[17:29:04.605] {
[17:29:04.605]     {
[17:29:04.605]         {
[17:29:04.605]             ...future.startTime <- base::Sys.time()
[17:29:04.605]             {
[17:29:04.605]                 {
[17:29:04.605]                   {
[17:29:04.605]                     base::local({
[17:29:04.605]                       has_future <- base::requireNamespace("future", 
[17:29:04.605]                         quietly = TRUE)
[17:29:04.605]                       if (has_future) {
[17:29:04.605]                         ns <- base::getNamespace("future")
[17:29:04.605]                         version <- ns[[".package"]][["version"]]
[17:29:04.605]                         if (is.null(version)) 
[17:29:04.605]                           version <- utils::packageVersion("future")
[17:29:04.605]                       }
[17:29:04.605]                       else {
[17:29:04.605]                         version <- NULL
[17:29:04.605]                       }
[17:29:04.605]                       if (!has_future || version < "1.8.0") {
[17:29:04.605]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:04.605]                           "", base::R.version$version.string), 
[17:29:04.605]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:04.605]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:04.605]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:04.605]                             "release", "version")], collapse = " "), 
[17:29:04.605]                           hostname = base::Sys.info()[["nodename"]])
[17:29:04.605]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:04.605]                           info)
[17:29:04.605]                         info <- base::paste(info, collapse = "; ")
[17:29:04.605]                         if (!has_future) {
[17:29:04.605]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:04.605]                             info)
[17:29:04.605]                         }
[17:29:04.605]                         else {
[17:29:04.605]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:04.605]                             info, version)
[17:29:04.605]                         }
[17:29:04.605]                         base::stop(msg)
[17:29:04.605]                       }
[17:29:04.605]                     })
[17:29:04.605]                   }
[17:29:04.605]                   ...future.strategy.old <- future::plan("list")
[17:29:04.605]                   options(future.plan = NULL)
[17:29:04.605]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:04.605]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:04.605]                 }
[17:29:04.605]                 ...future.workdir <- getwd()
[17:29:04.605]             }
[17:29:04.605]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:04.605]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:04.605]         }
[17:29:04.605]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:04.605]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:04.605]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:04.605]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:04.605]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:04.605]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:04.605]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:04.605]             base::names(...future.oldOptions))
[17:29:04.605]     }
[17:29:04.605]     if (FALSE) {
[17:29:04.605]     }
[17:29:04.605]     else {
[17:29:04.605]         if (TRUE) {
[17:29:04.605]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:04.605]                 open = "w")
[17:29:04.605]         }
[17:29:04.605]         else {
[17:29:04.605]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:04.605]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:04.605]         }
[17:29:04.605]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:04.605]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:04.605]             base::sink(type = "output", split = FALSE)
[17:29:04.605]             base::close(...future.stdout)
[17:29:04.605]         }, add = TRUE)
[17:29:04.605]     }
[17:29:04.605]     ...future.frame <- base::sys.nframe()
[17:29:04.605]     ...future.conditions <- base::list()
[17:29:04.605]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:04.605]     if (FALSE) {
[17:29:04.605]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:04.605]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:04.605]     }
[17:29:04.605]     ...future.result <- base::tryCatch({
[17:29:04.605]         base::withCallingHandlers({
[17:29:04.605]             ...future.value <- base::withVisible(base::local({
[17:29:04.605]                 Sys.sleep(0.1)
[17:29:04.605]                 kk
[17:29:04.605]             }))
[17:29:04.605]             future::FutureResult(value = ...future.value$value, 
[17:29:04.605]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:04.605]                   ...future.rng), globalenv = if (FALSE) 
[17:29:04.605]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:04.605]                     ...future.globalenv.names))
[17:29:04.605]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:04.605]         }, condition = base::local({
[17:29:04.605]             c <- base::c
[17:29:04.605]             inherits <- base::inherits
[17:29:04.605]             invokeRestart <- base::invokeRestart
[17:29:04.605]             length <- base::length
[17:29:04.605]             list <- base::list
[17:29:04.605]             seq.int <- base::seq.int
[17:29:04.605]             signalCondition <- base::signalCondition
[17:29:04.605]             sys.calls <- base::sys.calls
[17:29:04.605]             `[[` <- base::`[[`
[17:29:04.605]             `+` <- base::`+`
[17:29:04.605]             `<<-` <- base::`<<-`
[17:29:04.605]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:04.605]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:04.605]                   3L)]
[17:29:04.605]             }
[17:29:04.605]             function(cond) {
[17:29:04.605]                 is_error <- inherits(cond, "error")
[17:29:04.605]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:04.605]                   NULL)
[17:29:04.605]                 if (is_error) {
[17:29:04.605]                   sessionInformation <- function() {
[17:29:04.605]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:04.605]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:04.605]                       search = base::search(), system = base::Sys.info())
[17:29:04.605]                   }
[17:29:04.605]                   ...future.conditions[[length(...future.conditions) + 
[17:29:04.605]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:04.605]                     cond$call), session = sessionInformation(), 
[17:29:04.605]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:04.605]                   signalCondition(cond)
[17:29:04.605]                 }
[17:29:04.605]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:04.605]                 "immediateCondition"))) {
[17:29:04.605]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:04.605]                   ...future.conditions[[length(...future.conditions) + 
[17:29:04.605]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:04.605]                   if (TRUE && !signal) {
[17:29:04.605]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:04.605]                     {
[17:29:04.605]                       inherits <- base::inherits
[17:29:04.605]                       invokeRestart <- base::invokeRestart
[17:29:04.605]                       is.null <- base::is.null
[17:29:04.605]                       muffled <- FALSE
[17:29:04.605]                       if (inherits(cond, "message")) {
[17:29:04.605]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:04.605]                         if (muffled) 
[17:29:04.605]                           invokeRestart("muffleMessage")
[17:29:04.605]                       }
[17:29:04.605]                       else if (inherits(cond, "warning")) {
[17:29:04.605]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:04.605]                         if (muffled) 
[17:29:04.605]                           invokeRestart("muffleWarning")
[17:29:04.605]                       }
[17:29:04.605]                       else if (inherits(cond, "condition")) {
[17:29:04.605]                         if (!is.null(pattern)) {
[17:29:04.605]                           computeRestarts <- base::computeRestarts
[17:29:04.605]                           grepl <- base::grepl
[17:29:04.605]                           restarts <- computeRestarts(cond)
[17:29:04.605]                           for (restart in restarts) {
[17:29:04.605]                             name <- restart$name
[17:29:04.605]                             if (is.null(name)) 
[17:29:04.605]                               next
[17:29:04.605]                             if (!grepl(pattern, name)) 
[17:29:04.605]                               next
[17:29:04.605]                             invokeRestart(restart)
[17:29:04.605]                             muffled <- TRUE
[17:29:04.605]                             break
[17:29:04.605]                           }
[17:29:04.605]                         }
[17:29:04.605]                       }
[17:29:04.605]                       invisible(muffled)
[17:29:04.605]                     }
[17:29:04.605]                     muffleCondition(cond, pattern = "^muffle")
[17:29:04.605]                   }
[17:29:04.605]                 }
[17:29:04.605]                 else {
[17:29:04.605]                   if (TRUE) {
[17:29:04.605]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:04.605]                     {
[17:29:04.605]                       inherits <- base::inherits
[17:29:04.605]                       invokeRestart <- base::invokeRestart
[17:29:04.605]                       is.null <- base::is.null
[17:29:04.605]                       muffled <- FALSE
[17:29:04.605]                       if (inherits(cond, "message")) {
[17:29:04.605]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:04.605]                         if (muffled) 
[17:29:04.605]                           invokeRestart("muffleMessage")
[17:29:04.605]                       }
[17:29:04.605]                       else if (inherits(cond, "warning")) {
[17:29:04.605]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:04.605]                         if (muffled) 
[17:29:04.605]                           invokeRestart("muffleWarning")
[17:29:04.605]                       }
[17:29:04.605]                       else if (inherits(cond, "condition")) {
[17:29:04.605]                         if (!is.null(pattern)) {
[17:29:04.605]                           computeRestarts <- base::computeRestarts
[17:29:04.605]                           grepl <- base::grepl
[17:29:04.605]                           restarts <- computeRestarts(cond)
[17:29:04.605]                           for (restart in restarts) {
[17:29:04.605]                             name <- restart$name
[17:29:04.605]                             if (is.null(name)) 
[17:29:04.605]                               next
[17:29:04.605]                             if (!grepl(pattern, name)) 
[17:29:04.605]                               next
[17:29:04.605]                             invokeRestart(restart)
[17:29:04.605]                             muffled <- TRUE
[17:29:04.605]                             break
[17:29:04.605]                           }
[17:29:04.605]                         }
[17:29:04.605]                       }
[17:29:04.605]                       invisible(muffled)
[17:29:04.605]                     }
[17:29:04.605]                     muffleCondition(cond, pattern = "^muffle")
[17:29:04.605]                   }
[17:29:04.605]                 }
[17:29:04.605]             }
[17:29:04.605]         }))
[17:29:04.605]     }, error = function(ex) {
[17:29:04.605]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:04.605]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:04.605]                 ...future.rng), started = ...future.startTime, 
[17:29:04.605]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:04.605]             version = "1.8"), class = "FutureResult")
[17:29:04.605]     }, finally = {
[17:29:04.605]         if (!identical(...future.workdir, getwd())) 
[17:29:04.605]             setwd(...future.workdir)
[17:29:04.605]         {
[17:29:04.605]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:04.605]                 ...future.oldOptions$nwarnings <- NULL
[17:29:04.605]             }
[17:29:04.605]             base::options(...future.oldOptions)
[17:29:04.605]             if (.Platform$OS.type == "windows") {
[17:29:04.605]                 old_names <- names(...future.oldEnvVars)
[17:29:04.605]                 envs <- base::Sys.getenv()
[17:29:04.605]                 names <- names(envs)
[17:29:04.605]                 common <- intersect(names, old_names)
[17:29:04.605]                 added <- setdiff(names, old_names)
[17:29:04.605]                 removed <- setdiff(old_names, names)
[17:29:04.605]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:04.605]                   envs[common]]
[17:29:04.605]                 NAMES <- toupper(changed)
[17:29:04.605]                 args <- list()
[17:29:04.605]                 for (kk in seq_along(NAMES)) {
[17:29:04.605]                   name <- changed[[kk]]
[17:29:04.605]                   NAME <- NAMES[[kk]]
[17:29:04.605]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:04.605]                     next
[17:29:04.605]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:04.605]                 }
[17:29:04.605]                 NAMES <- toupper(added)
[17:29:04.605]                 for (kk in seq_along(NAMES)) {
[17:29:04.605]                   name <- added[[kk]]
[17:29:04.605]                   NAME <- NAMES[[kk]]
[17:29:04.605]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:04.605]                     next
[17:29:04.605]                   args[[name]] <- ""
[17:29:04.605]                 }
[17:29:04.605]                 NAMES <- toupper(removed)
[17:29:04.605]                 for (kk in seq_along(NAMES)) {
[17:29:04.605]                   name <- removed[[kk]]
[17:29:04.605]                   NAME <- NAMES[[kk]]
[17:29:04.605]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:04.605]                     next
[17:29:04.605]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:04.605]                 }
[17:29:04.605]                 if (length(args) > 0) 
[17:29:04.605]                   base::do.call(base::Sys.setenv, args = args)
[17:29:04.605]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:04.605]             }
[17:29:04.605]             else {
[17:29:04.605]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:04.605]             }
[17:29:04.605]             {
[17:29:04.605]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:04.605]                   0L) {
[17:29:04.605]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:04.605]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:04.605]                   base::options(opts)
[17:29:04.605]                 }
[17:29:04.605]                 {
[17:29:04.605]                   {
[17:29:04.605]                     NULL
[17:29:04.605]                     RNGkind("Mersenne-Twister")
[17:29:04.605]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:04.605]                       inherits = FALSE)
[17:29:04.605]                   }
[17:29:04.605]                   options(future.plan = NULL)
[17:29:04.605]                   if (is.na(NA_character_)) 
[17:29:04.605]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:04.605]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:04.605]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:04.605]                     .init = FALSE)
[17:29:04.605]                 }
[17:29:04.605]             }
[17:29:04.605]         }
[17:29:04.605]     })
[17:29:04.605]     if (TRUE) {
[17:29:04.605]         base::sink(type = "output", split = FALSE)
[17:29:04.605]         if (TRUE) {
[17:29:04.605]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:04.605]         }
[17:29:04.605]         else {
[17:29:04.605]             ...future.result["stdout"] <- base::list(NULL)
[17:29:04.605]         }
[17:29:04.605]         base::close(...future.stdout)
[17:29:04.605]         ...future.stdout <- NULL
[17:29:04.605]     }
[17:29:04.605]     ...future.result$conditions <- ...future.conditions
[17:29:04.605]     ...future.result$finished <- base::Sys.time()
[17:29:04.605]     ...future.result
[17:29:04.605] }
[17:29:04.611] assign_globals() ...
[17:29:04.611] List of 1
[17:29:04.611]  $ kk: int 2
[17:29:04.611]  - attr(*, "where")=List of 1
[17:29:04.611]   ..$ kk:<environment: R_EmptyEnv> 
[17:29:04.611]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:04.611]  - attr(*, "resolved")= logi FALSE
[17:29:04.611]  - attr(*, "total_size")= int 35
[17:29:04.611]  - attr(*, "already-done")= logi TRUE
[17:29:04.615] - copied 'kk' to environment
[17:29:04.615] assign_globals() ... done
[17:29:04.616] plan(): Setting new future strategy stack:
[17:29:04.616] List of future strategies:
[17:29:04.616] 1. sequential:
[17:29:04.616]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:04.616]    - tweaked: FALSE
[17:29:04.616]    - call: NULL
[17:29:04.617] plan(): nbrOfWorkers() = 1
[17:29:04.723] plan(): Setting new future strategy stack:
[17:29:04.723] List of future strategies:
[17:29:04.723] 1. sequential:
[17:29:04.723]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:04.723]    - tweaked: FALSE
[17:29:04.723]    - call: plan(strategy)
[17:29:04.725] plan(): nbrOfWorkers() = 1
[17:29:04.725] SequentialFuture started (and completed)
[17:29:04.726] - Launch lazy future ... done
[17:29:04.726] run() for 'SequentialFuture' ... done
[17:29:04.727] getGlobalsAndPackages() ...
[17:29:04.727] Searching for globals...
[17:29:04.729] - globals found: [3] '{', 'Sys.sleep', 'kk'
[17:29:04.730] Searching for globals ... DONE
[17:29:04.730] Resolving globals: FALSE
[17:29:04.731] The total size of the 1 globals is 35 bytes (35 bytes)
[17:29:04.732] The total size of the 1 globals exported for future expression ('{; Sys.sleep(0.1); kk; }') is 35 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'kk' (35 bytes of class 'numeric')
[17:29:04.732] - globals: [1] 'kk'
[17:29:04.733] 
[17:29:04.733] getGlobalsAndPackages() ... DONE
[17:29:04.734] run() for 'Future' ...
[17:29:04.734] - state: 'created'
[17:29:04.735] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:04.735] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:04.736] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:04.736]   - Field: 'label'
[17:29:04.736]   - Field: 'local'
[17:29:04.737]   - Field: 'owner'
[17:29:04.737]   - Field: 'envir'
[17:29:04.737]   - Field: 'packages'
[17:29:04.738]   - Field: 'gc'
[17:29:04.738]   - Field: 'conditions'
[17:29:04.738]   - Field: 'expr'
[17:29:04.739]   - Field: 'uuid'
[17:29:04.739]   - Field: 'seed'
[17:29:04.739]   - Field: 'version'
[17:29:04.740]   - Field: 'result'
[17:29:04.740]   - Field: 'asynchronous'
[17:29:04.741]   - Field: 'calls'
[17:29:04.741]   - Field: 'globals'
[17:29:04.741]   - Field: 'stdout'
[17:29:04.742]   - Field: 'earlySignal'
[17:29:04.742]   - Field: 'lazy'
[17:29:04.742]   - Field: 'state'
[17:29:04.743] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:04.743] - Launch lazy future ...
[17:29:04.744] Packages needed by the future expression (n = 0): <none>
[17:29:04.744] Packages needed by future strategies (n = 0): <none>
[17:29:04.745] {
[17:29:04.745]     {
[17:29:04.745]         {
[17:29:04.745]             ...future.startTime <- base::Sys.time()
[17:29:04.745]             {
[17:29:04.745]                 {
[17:29:04.745]                   {
[17:29:04.745]                     base::local({
[17:29:04.745]                       has_future <- base::requireNamespace("future", 
[17:29:04.745]                         quietly = TRUE)
[17:29:04.745]                       if (has_future) {
[17:29:04.745]                         ns <- base::getNamespace("future")
[17:29:04.745]                         version <- ns[[".package"]][["version"]]
[17:29:04.745]                         if (is.null(version)) 
[17:29:04.745]                           version <- utils::packageVersion("future")
[17:29:04.745]                       }
[17:29:04.745]                       else {
[17:29:04.745]                         version <- NULL
[17:29:04.745]                       }
[17:29:04.745]                       if (!has_future || version < "1.8.0") {
[17:29:04.745]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:04.745]                           "", base::R.version$version.string), 
[17:29:04.745]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:04.745]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:04.745]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:04.745]                             "release", "version")], collapse = " "), 
[17:29:04.745]                           hostname = base::Sys.info()[["nodename"]])
[17:29:04.745]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:04.745]                           info)
[17:29:04.745]                         info <- base::paste(info, collapse = "; ")
[17:29:04.745]                         if (!has_future) {
[17:29:04.745]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:04.745]                             info)
[17:29:04.745]                         }
[17:29:04.745]                         else {
[17:29:04.745]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:04.745]                             info, version)
[17:29:04.745]                         }
[17:29:04.745]                         base::stop(msg)
[17:29:04.745]                       }
[17:29:04.745]                     })
[17:29:04.745]                   }
[17:29:04.745]                   ...future.strategy.old <- future::plan("list")
[17:29:04.745]                   options(future.plan = NULL)
[17:29:04.745]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:04.745]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:04.745]                 }
[17:29:04.745]                 ...future.workdir <- getwd()
[17:29:04.745]             }
[17:29:04.745]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:04.745]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:04.745]         }
[17:29:04.745]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:04.745]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:04.745]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:04.745]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:04.745]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:04.745]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:04.745]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:04.745]             base::names(...future.oldOptions))
[17:29:04.745]     }
[17:29:04.745]     if (FALSE) {
[17:29:04.745]     }
[17:29:04.745]     else {
[17:29:04.745]         if (TRUE) {
[17:29:04.745]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:04.745]                 open = "w")
[17:29:04.745]         }
[17:29:04.745]         else {
[17:29:04.745]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:04.745]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:04.745]         }
[17:29:04.745]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:04.745]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:04.745]             base::sink(type = "output", split = FALSE)
[17:29:04.745]             base::close(...future.stdout)
[17:29:04.745]         }, add = TRUE)
[17:29:04.745]     }
[17:29:04.745]     ...future.frame <- base::sys.nframe()
[17:29:04.745]     ...future.conditions <- base::list()
[17:29:04.745]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:04.745]     if (FALSE) {
[17:29:04.745]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:04.745]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:04.745]     }
[17:29:04.745]     ...future.result <- base::tryCatch({
[17:29:04.745]         base::withCallingHandlers({
[17:29:04.745]             ...future.value <- base::withVisible(base::local({
[17:29:04.745]                 Sys.sleep(0.1)
[17:29:04.745]                 kk
[17:29:04.745]             }))
[17:29:04.745]             future::FutureResult(value = ...future.value$value, 
[17:29:04.745]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:04.745]                   ...future.rng), globalenv = if (FALSE) 
[17:29:04.745]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:04.745]                     ...future.globalenv.names))
[17:29:04.745]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:04.745]         }, condition = base::local({
[17:29:04.745]             c <- base::c
[17:29:04.745]             inherits <- base::inherits
[17:29:04.745]             invokeRestart <- base::invokeRestart
[17:29:04.745]             length <- base::length
[17:29:04.745]             list <- base::list
[17:29:04.745]             seq.int <- base::seq.int
[17:29:04.745]             signalCondition <- base::signalCondition
[17:29:04.745]             sys.calls <- base::sys.calls
[17:29:04.745]             `[[` <- base::`[[`
[17:29:04.745]             `+` <- base::`+`
[17:29:04.745]             `<<-` <- base::`<<-`
[17:29:04.745]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:04.745]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:04.745]                   3L)]
[17:29:04.745]             }
[17:29:04.745]             function(cond) {
[17:29:04.745]                 is_error <- inherits(cond, "error")
[17:29:04.745]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:04.745]                   NULL)
[17:29:04.745]                 if (is_error) {
[17:29:04.745]                   sessionInformation <- function() {
[17:29:04.745]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:04.745]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:04.745]                       search = base::search(), system = base::Sys.info())
[17:29:04.745]                   }
[17:29:04.745]                   ...future.conditions[[length(...future.conditions) + 
[17:29:04.745]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:04.745]                     cond$call), session = sessionInformation(), 
[17:29:04.745]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:04.745]                   signalCondition(cond)
[17:29:04.745]                 }
[17:29:04.745]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:04.745]                 "immediateCondition"))) {
[17:29:04.745]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:04.745]                   ...future.conditions[[length(...future.conditions) + 
[17:29:04.745]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:04.745]                   if (TRUE && !signal) {
[17:29:04.745]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:04.745]                     {
[17:29:04.745]                       inherits <- base::inherits
[17:29:04.745]                       invokeRestart <- base::invokeRestart
[17:29:04.745]                       is.null <- base::is.null
[17:29:04.745]                       muffled <- FALSE
[17:29:04.745]                       if (inherits(cond, "message")) {
[17:29:04.745]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:04.745]                         if (muffled) 
[17:29:04.745]                           invokeRestart("muffleMessage")
[17:29:04.745]                       }
[17:29:04.745]                       else if (inherits(cond, "warning")) {
[17:29:04.745]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:04.745]                         if (muffled) 
[17:29:04.745]                           invokeRestart("muffleWarning")
[17:29:04.745]                       }
[17:29:04.745]                       else if (inherits(cond, "condition")) {
[17:29:04.745]                         if (!is.null(pattern)) {
[17:29:04.745]                           computeRestarts <- base::computeRestarts
[17:29:04.745]                           grepl <- base::grepl
[17:29:04.745]                           restarts <- computeRestarts(cond)
[17:29:04.745]                           for (restart in restarts) {
[17:29:04.745]                             name <- restart$name
[17:29:04.745]                             if (is.null(name)) 
[17:29:04.745]                               next
[17:29:04.745]                             if (!grepl(pattern, name)) 
[17:29:04.745]                               next
[17:29:04.745]                             invokeRestart(restart)
[17:29:04.745]                             muffled <- TRUE
[17:29:04.745]                             break
[17:29:04.745]                           }
[17:29:04.745]                         }
[17:29:04.745]                       }
[17:29:04.745]                       invisible(muffled)
[17:29:04.745]                     }
[17:29:04.745]                     muffleCondition(cond, pattern = "^muffle")
[17:29:04.745]                   }
[17:29:04.745]                 }
[17:29:04.745]                 else {
[17:29:04.745]                   if (TRUE) {
[17:29:04.745]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:04.745]                     {
[17:29:04.745]                       inherits <- base::inherits
[17:29:04.745]                       invokeRestart <- base::invokeRestart
[17:29:04.745]                       is.null <- base::is.null
[17:29:04.745]                       muffled <- FALSE
[17:29:04.745]                       if (inherits(cond, "message")) {
[17:29:04.745]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:04.745]                         if (muffled) 
[17:29:04.745]                           invokeRestart("muffleMessage")
[17:29:04.745]                       }
[17:29:04.745]                       else if (inherits(cond, "warning")) {
[17:29:04.745]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:04.745]                         if (muffled) 
[17:29:04.745]                           invokeRestart("muffleWarning")
[17:29:04.745]                       }
[17:29:04.745]                       else if (inherits(cond, "condition")) {
[17:29:04.745]                         if (!is.null(pattern)) {
[17:29:04.745]                           computeRestarts <- base::computeRestarts
[17:29:04.745]                           grepl <- base::grepl
[17:29:04.745]                           restarts <- computeRestarts(cond)
[17:29:04.745]                           for (restart in restarts) {
[17:29:04.745]                             name <- restart$name
[17:29:04.745]                             if (is.null(name)) 
[17:29:04.745]                               next
[17:29:04.745]                             if (!grepl(pattern, name)) 
[17:29:04.745]                               next
[17:29:04.745]                             invokeRestart(restart)
[17:29:04.745]                             muffled <- TRUE
[17:29:04.745]                             break
[17:29:04.745]                           }
[17:29:04.745]                         }
[17:29:04.745]                       }
[17:29:04.745]                       invisible(muffled)
[17:29:04.745]                     }
[17:29:04.745]                     muffleCondition(cond, pattern = "^muffle")
[17:29:04.745]                   }
[17:29:04.745]                 }
[17:29:04.745]             }
[17:29:04.745]         }))
[17:29:04.745]     }, error = function(ex) {
[17:29:04.745]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:04.745]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:04.745]                 ...future.rng), started = ...future.startTime, 
[17:29:04.745]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:04.745]             version = "1.8"), class = "FutureResult")
[17:29:04.745]     }, finally = {
[17:29:04.745]         if (!identical(...future.workdir, getwd())) 
[17:29:04.745]             setwd(...future.workdir)
[17:29:04.745]         {
[17:29:04.745]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:04.745]                 ...future.oldOptions$nwarnings <- NULL
[17:29:04.745]             }
[17:29:04.745]             base::options(...future.oldOptions)
[17:29:04.745]             if (.Platform$OS.type == "windows") {
[17:29:04.745]                 old_names <- names(...future.oldEnvVars)
[17:29:04.745]                 envs <- base::Sys.getenv()
[17:29:04.745]                 names <- names(envs)
[17:29:04.745]                 common <- intersect(names, old_names)
[17:29:04.745]                 added <- setdiff(names, old_names)
[17:29:04.745]                 removed <- setdiff(old_names, names)
[17:29:04.745]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:04.745]                   envs[common]]
[17:29:04.745]                 NAMES <- toupper(changed)
[17:29:04.745]                 args <- list()
[17:29:04.745]                 for (kk in seq_along(NAMES)) {
[17:29:04.745]                   name <- changed[[kk]]
[17:29:04.745]                   NAME <- NAMES[[kk]]
[17:29:04.745]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:04.745]                     next
[17:29:04.745]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:04.745]                 }
[17:29:04.745]                 NAMES <- toupper(added)
[17:29:04.745]                 for (kk in seq_along(NAMES)) {
[17:29:04.745]                   name <- added[[kk]]
[17:29:04.745]                   NAME <- NAMES[[kk]]
[17:29:04.745]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:04.745]                     next
[17:29:04.745]                   args[[name]] <- ""
[17:29:04.745]                 }
[17:29:04.745]                 NAMES <- toupper(removed)
[17:29:04.745]                 for (kk in seq_along(NAMES)) {
[17:29:04.745]                   name <- removed[[kk]]
[17:29:04.745]                   NAME <- NAMES[[kk]]
[17:29:04.745]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:04.745]                     next
[17:29:04.745]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:04.745]                 }
[17:29:04.745]                 if (length(args) > 0) 
[17:29:04.745]                   base::do.call(base::Sys.setenv, args = args)
[17:29:04.745]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:04.745]             }
[17:29:04.745]             else {
[17:29:04.745]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:04.745]             }
[17:29:04.745]             {
[17:29:04.745]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:04.745]                   0L) {
[17:29:04.745]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:04.745]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:04.745]                   base::options(opts)
[17:29:04.745]                 }
[17:29:04.745]                 {
[17:29:04.745]                   {
[17:29:04.745]                     NULL
[17:29:04.745]                     RNGkind("Mersenne-Twister")
[17:29:04.745]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:04.745]                       inherits = FALSE)
[17:29:04.745]                   }
[17:29:04.745]                   options(future.plan = NULL)
[17:29:04.745]                   if (is.na(NA_character_)) 
[17:29:04.745]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:04.745]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:04.745]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:04.745]                     .init = FALSE)
[17:29:04.745]                 }
[17:29:04.745]             }
[17:29:04.745]         }
[17:29:04.745]     })
[17:29:04.745]     if (TRUE) {
[17:29:04.745]         base::sink(type = "output", split = FALSE)
[17:29:04.745]         if (TRUE) {
[17:29:04.745]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:04.745]         }
[17:29:04.745]         else {
[17:29:04.745]             ...future.result["stdout"] <- base::list(NULL)
[17:29:04.745]         }
[17:29:04.745]         base::close(...future.stdout)
[17:29:04.745]         ...future.stdout <- NULL
[17:29:04.745]     }
[17:29:04.745]     ...future.result$conditions <- ...future.conditions
[17:29:04.745]     ...future.result$finished <- base::Sys.time()
[17:29:04.745]     ...future.result
[17:29:04.745] }
[17:29:04.753] assign_globals() ...
[17:29:04.753] List of 1
[17:29:04.753]  $ kk: int 3
[17:29:04.753]  - attr(*, "where")=List of 1
[17:29:04.753]   ..$ kk:<environment: R_EmptyEnv> 
[17:29:04.753]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:04.753]  - attr(*, "resolved")= logi FALSE
[17:29:04.753]  - attr(*, "total_size")= int 35
[17:29:04.753]  - attr(*, "already-done")= logi TRUE
[17:29:04.761] - copied 'kk' to environment
[17:29:04.762] assign_globals() ... done
[17:29:04.762] plan(): Setting new future strategy stack:
[17:29:04.763] List of future strategies:
[17:29:04.763] 1. sequential:
[17:29:04.763]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:04.763]    - tweaked: FALSE
[17:29:04.763]    - call: NULL
[17:29:04.764] plan(): nbrOfWorkers() = 1
[17:29:04.879] plan(): Setting new future strategy stack:
[17:29:04.879] List of future strategies:
[17:29:04.879] 1. sequential:
[17:29:04.879]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:04.879]    - tweaked: FALSE
[17:29:04.879]    - call: plan(strategy)
[17:29:04.880] plan(): nbrOfWorkers() = 1
[17:29:04.881] SequentialFuture started (and completed)
[17:29:04.881] - Launch lazy future ... done
[17:29:04.881] run() for 'SequentialFuture' ... done
[17:29:04.882] resolve() on list ...
[17:29:04.882]  recursive: 0
[17:29:04.882]  length: 3
[17:29:04.883] 
[17:29:04.883] resolved() for 'SequentialFuture' ...
[17:29:04.883] - state: 'finished'
[17:29:04.883] - run: TRUE
[17:29:04.884] - result: 'FutureResult'
[17:29:04.884] resolved() for 'SequentialFuture' ... done
[17:29:04.884] Future #1
[17:29:04.885]  length: 2 (resolved future 1)
[17:29:04.885] resolved() for 'SequentialFuture' ...
[17:29:04.885] - state: 'finished'
[17:29:04.886] - run: TRUE
[17:29:04.886] - result: 'FutureResult'
[17:29:04.886] resolved() for 'SequentialFuture' ... done
[17:29:04.887] Future #2
[17:29:04.887]  length: 1 (resolved future 2)
[17:29:04.887] resolved() for 'SequentialFuture' ...
[17:29:04.888] - state: 'finished'
[17:29:04.888] - run: TRUE
[17:29:04.888] - result: 'FutureResult'
[17:29:04.888] resolved() for 'SequentialFuture' ... done
[17:29:04.889] Future #3
[17:29:04.889]  length: 0 (resolved future 3)
[17:29:04.889] resolve() on list ... DONE
[17:29:04.890] getGlobalsAndPackages() ...
[17:29:04.890] Searching for globals...
[17:29:04.892] - globals found: [3] '{', 'Sys.sleep', 'kk'
[17:29:04.892] Searching for globals ... DONE
[17:29:04.893] Resolving globals: FALSE
[17:29:04.894] The total size of the 1 globals is 35 bytes (35 bytes)
[17:29:04.894] The total size of the 1 globals exported for future expression ('{; Sys.sleep(0.1); kk; }') is 35 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'kk' (35 bytes of class 'numeric')
[17:29:04.895] - globals: [1] 'kk'
[17:29:04.895] 
[17:29:04.895] getGlobalsAndPackages() ... DONE
[17:29:04.896] getGlobalsAndPackages() ...
[17:29:04.896] Searching for globals...
[17:29:04.898] - globals found: [3] '{', 'Sys.sleep', 'kk'
[17:29:04.898] Searching for globals ... DONE
[17:29:04.898] Resolving globals: FALSE
[17:29:04.899] The total size of the 1 globals is 35 bytes (35 bytes)
[17:29:04.900] The total size of the 1 globals exported for future expression ('{; Sys.sleep(0.1); kk; }') is 35 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'kk' (35 bytes of class 'numeric')
[17:29:04.900] - globals: [1] 'kk'
[17:29:04.901] 
[17:29:04.901] getGlobalsAndPackages() ... DONE
[17:29:04.901] getGlobalsAndPackages() ...
[17:29:04.902] Searching for globals...
[17:29:04.904] - globals found: [3] '{', 'Sys.sleep', 'kk'
[17:29:04.904] Searching for globals ... DONE
[17:29:04.904] Resolving globals: FALSE
[17:29:04.905] The total size of the 1 globals is 35 bytes (35 bytes)
[17:29:04.906] The total size of the 1 globals exported for future expression ('{; Sys.sleep(0.1); kk; }') is 35 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'kk' (35 bytes of class 'numeric')
[17:29:04.906] - globals: [1] 'kk'
[17:29:04.906] 
[17:29:04.906] getGlobalsAndPackages() ... DONE
[17:29:04.907] resolve() on list ...
[17:29:04.907]  recursive: 0
[17:29:04.908]  length: 3
[17:29:04.908] 
[17:29:04.908] run() for 'Future' ...
[17:29:04.908] - state: 'created'
[17:29:04.909] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:04.909] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:04.910] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:04.910]   - Field: 'label'
[17:29:04.910]   - Field: 'local'
[17:29:04.911]   - Field: 'owner'
[17:29:04.911]   - Field: 'envir'
[17:29:04.911]   - Field: 'packages'
[17:29:04.912]   - Field: 'gc'
[17:29:04.912]   - Field: 'conditions'
[17:29:04.912]   - Field: 'expr'
[17:29:04.913]   - Field: 'uuid'
[17:29:04.913]   - Field: 'seed'
[17:29:04.913]   - Field: 'version'
[17:29:04.913]   - Field: 'result'
[17:29:04.914]   - Field: 'asynchronous'
[17:29:04.914]   - Field: 'calls'
[17:29:04.914]   - Field: 'globals'
[17:29:04.915]   - Field: 'stdout'
[17:29:04.915]   - Field: 'earlySignal'
[17:29:04.915]   - Field: 'lazy'
[17:29:04.915]   - Field: 'state'
[17:29:04.916] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:04.916] - Launch lazy future ...
[17:29:04.919] Packages needed by the future expression (n = 0): <none>
[17:29:04.919] Packages needed by future strategies (n = 0): <none>
[17:29:04.920] {
[17:29:04.920]     {
[17:29:04.920]         {
[17:29:04.920]             ...future.startTime <- base::Sys.time()
[17:29:04.920]             {
[17:29:04.920]                 {
[17:29:04.920]                   {
[17:29:04.920]                     base::local({
[17:29:04.920]                       has_future <- base::requireNamespace("future", 
[17:29:04.920]                         quietly = TRUE)
[17:29:04.920]                       if (has_future) {
[17:29:04.920]                         ns <- base::getNamespace("future")
[17:29:04.920]                         version <- ns[[".package"]][["version"]]
[17:29:04.920]                         if (is.null(version)) 
[17:29:04.920]                           version <- utils::packageVersion("future")
[17:29:04.920]                       }
[17:29:04.920]                       else {
[17:29:04.920]                         version <- NULL
[17:29:04.920]                       }
[17:29:04.920]                       if (!has_future || version < "1.8.0") {
[17:29:04.920]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:04.920]                           "", base::R.version$version.string), 
[17:29:04.920]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:04.920]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:04.920]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:04.920]                             "release", "version")], collapse = " "), 
[17:29:04.920]                           hostname = base::Sys.info()[["nodename"]])
[17:29:04.920]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:04.920]                           info)
[17:29:04.920]                         info <- base::paste(info, collapse = "; ")
[17:29:04.920]                         if (!has_future) {
[17:29:04.920]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:04.920]                             info)
[17:29:04.920]                         }
[17:29:04.920]                         else {
[17:29:04.920]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:04.920]                             info, version)
[17:29:04.920]                         }
[17:29:04.920]                         base::stop(msg)
[17:29:04.920]                       }
[17:29:04.920]                     })
[17:29:04.920]                   }
[17:29:04.920]                   ...future.strategy.old <- future::plan("list")
[17:29:04.920]                   options(future.plan = NULL)
[17:29:04.920]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:04.920]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:04.920]                 }
[17:29:04.920]                 ...future.workdir <- getwd()
[17:29:04.920]             }
[17:29:04.920]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:04.920]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:04.920]         }
[17:29:04.920]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:04.920]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:04.920]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:04.920]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:04.920]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:04.920]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:04.920]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:04.920]             base::names(...future.oldOptions))
[17:29:04.920]     }
[17:29:04.920]     if (FALSE) {
[17:29:04.920]     }
[17:29:04.920]     else {
[17:29:04.920]         if (TRUE) {
[17:29:04.920]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:04.920]                 open = "w")
[17:29:04.920]         }
[17:29:04.920]         else {
[17:29:04.920]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:04.920]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:04.920]         }
[17:29:04.920]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:04.920]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:04.920]             base::sink(type = "output", split = FALSE)
[17:29:04.920]             base::close(...future.stdout)
[17:29:04.920]         }, add = TRUE)
[17:29:04.920]     }
[17:29:04.920]     ...future.frame <- base::sys.nframe()
[17:29:04.920]     ...future.conditions <- base::list()
[17:29:04.920]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:04.920]     if (FALSE) {
[17:29:04.920]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:04.920]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:04.920]     }
[17:29:04.920]     ...future.result <- base::tryCatch({
[17:29:04.920]         base::withCallingHandlers({
[17:29:04.920]             ...future.value <- base::withVisible(base::local({
[17:29:04.920]                 Sys.sleep(0.1)
[17:29:04.920]                 kk
[17:29:04.920]             }))
[17:29:04.920]             future::FutureResult(value = ...future.value$value, 
[17:29:04.920]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:04.920]                   ...future.rng), globalenv = if (FALSE) 
[17:29:04.920]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:04.920]                     ...future.globalenv.names))
[17:29:04.920]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:04.920]         }, condition = base::local({
[17:29:04.920]             c <- base::c
[17:29:04.920]             inherits <- base::inherits
[17:29:04.920]             invokeRestart <- base::invokeRestart
[17:29:04.920]             length <- base::length
[17:29:04.920]             list <- base::list
[17:29:04.920]             seq.int <- base::seq.int
[17:29:04.920]             signalCondition <- base::signalCondition
[17:29:04.920]             sys.calls <- base::sys.calls
[17:29:04.920]             `[[` <- base::`[[`
[17:29:04.920]             `+` <- base::`+`
[17:29:04.920]             `<<-` <- base::`<<-`
[17:29:04.920]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:04.920]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:04.920]                   3L)]
[17:29:04.920]             }
[17:29:04.920]             function(cond) {
[17:29:04.920]                 is_error <- inherits(cond, "error")
[17:29:04.920]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:04.920]                   NULL)
[17:29:04.920]                 if (is_error) {
[17:29:04.920]                   sessionInformation <- function() {
[17:29:04.920]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:04.920]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:04.920]                       search = base::search(), system = base::Sys.info())
[17:29:04.920]                   }
[17:29:04.920]                   ...future.conditions[[length(...future.conditions) + 
[17:29:04.920]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:04.920]                     cond$call), session = sessionInformation(), 
[17:29:04.920]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:04.920]                   signalCondition(cond)
[17:29:04.920]                 }
[17:29:04.920]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:04.920]                 "immediateCondition"))) {
[17:29:04.920]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:04.920]                   ...future.conditions[[length(...future.conditions) + 
[17:29:04.920]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:04.920]                   if (TRUE && !signal) {
[17:29:04.920]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:04.920]                     {
[17:29:04.920]                       inherits <- base::inherits
[17:29:04.920]                       invokeRestart <- base::invokeRestart
[17:29:04.920]                       is.null <- base::is.null
[17:29:04.920]                       muffled <- FALSE
[17:29:04.920]                       if (inherits(cond, "message")) {
[17:29:04.920]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:04.920]                         if (muffled) 
[17:29:04.920]                           invokeRestart("muffleMessage")
[17:29:04.920]                       }
[17:29:04.920]                       else if (inherits(cond, "warning")) {
[17:29:04.920]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:04.920]                         if (muffled) 
[17:29:04.920]                           invokeRestart("muffleWarning")
[17:29:04.920]                       }
[17:29:04.920]                       else if (inherits(cond, "condition")) {
[17:29:04.920]                         if (!is.null(pattern)) {
[17:29:04.920]                           computeRestarts <- base::computeRestarts
[17:29:04.920]                           grepl <- base::grepl
[17:29:04.920]                           restarts <- computeRestarts(cond)
[17:29:04.920]                           for (restart in restarts) {
[17:29:04.920]                             name <- restart$name
[17:29:04.920]                             if (is.null(name)) 
[17:29:04.920]                               next
[17:29:04.920]                             if (!grepl(pattern, name)) 
[17:29:04.920]                               next
[17:29:04.920]                             invokeRestart(restart)
[17:29:04.920]                             muffled <- TRUE
[17:29:04.920]                             break
[17:29:04.920]                           }
[17:29:04.920]                         }
[17:29:04.920]                       }
[17:29:04.920]                       invisible(muffled)
[17:29:04.920]                     }
[17:29:04.920]                     muffleCondition(cond, pattern = "^muffle")
[17:29:04.920]                   }
[17:29:04.920]                 }
[17:29:04.920]                 else {
[17:29:04.920]                   if (TRUE) {
[17:29:04.920]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:04.920]                     {
[17:29:04.920]                       inherits <- base::inherits
[17:29:04.920]                       invokeRestart <- base::invokeRestart
[17:29:04.920]                       is.null <- base::is.null
[17:29:04.920]                       muffled <- FALSE
[17:29:04.920]                       if (inherits(cond, "message")) {
[17:29:04.920]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:04.920]                         if (muffled) 
[17:29:04.920]                           invokeRestart("muffleMessage")
[17:29:04.920]                       }
[17:29:04.920]                       else if (inherits(cond, "warning")) {
[17:29:04.920]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:04.920]                         if (muffled) 
[17:29:04.920]                           invokeRestart("muffleWarning")
[17:29:04.920]                       }
[17:29:04.920]                       else if (inherits(cond, "condition")) {
[17:29:04.920]                         if (!is.null(pattern)) {
[17:29:04.920]                           computeRestarts <- base::computeRestarts
[17:29:04.920]                           grepl <- base::grepl
[17:29:04.920]                           restarts <- computeRestarts(cond)
[17:29:04.920]                           for (restart in restarts) {
[17:29:04.920]                             name <- restart$name
[17:29:04.920]                             if (is.null(name)) 
[17:29:04.920]                               next
[17:29:04.920]                             if (!grepl(pattern, name)) 
[17:29:04.920]                               next
[17:29:04.920]                             invokeRestart(restart)
[17:29:04.920]                             muffled <- TRUE
[17:29:04.920]                             break
[17:29:04.920]                           }
[17:29:04.920]                         }
[17:29:04.920]                       }
[17:29:04.920]                       invisible(muffled)
[17:29:04.920]                     }
[17:29:04.920]                     muffleCondition(cond, pattern = "^muffle")
[17:29:04.920]                   }
[17:29:04.920]                 }
[17:29:04.920]             }
[17:29:04.920]         }))
[17:29:04.920]     }, error = function(ex) {
[17:29:04.920]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:04.920]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:04.920]                 ...future.rng), started = ...future.startTime, 
[17:29:04.920]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:04.920]             version = "1.8"), class = "FutureResult")
[17:29:04.920]     }, finally = {
[17:29:04.920]         if (!identical(...future.workdir, getwd())) 
[17:29:04.920]             setwd(...future.workdir)
[17:29:04.920]         {
[17:29:04.920]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:04.920]                 ...future.oldOptions$nwarnings <- NULL
[17:29:04.920]             }
[17:29:04.920]             base::options(...future.oldOptions)
[17:29:04.920]             if (.Platform$OS.type == "windows") {
[17:29:04.920]                 old_names <- names(...future.oldEnvVars)
[17:29:04.920]                 envs <- base::Sys.getenv()
[17:29:04.920]                 names <- names(envs)
[17:29:04.920]                 common <- intersect(names, old_names)
[17:29:04.920]                 added <- setdiff(names, old_names)
[17:29:04.920]                 removed <- setdiff(old_names, names)
[17:29:04.920]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:04.920]                   envs[common]]
[17:29:04.920]                 NAMES <- toupper(changed)
[17:29:04.920]                 args <- list()
[17:29:04.920]                 for (kk in seq_along(NAMES)) {
[17:29:04.920]                   name <- changed[[kk]]
[17:29:04.920]                   NAME <- NAMES[[kk]]
[17:29:04.920]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:04.920]                     next
[17:29:04.920]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:04.920]                 }
[17:29:04.920]                 NAMES <- toupper(added)
[17:29:04.920]                 for (kk in seq_along(NAMES)) {
[17:29:04.920]                   name <- added[[kk]]
[17:29:04.920]                   NAME <- NAMES[[kk]]
[17:29:04.920]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:04.920]                     next
[17:29:04.920]                   args[[name]] <- ""
[17:29:04.920]                 }
[17:29:04.920]                 NAMES <- toupper(removed)
[17:29:04.920]                 for (kk in seq_along(NAMES)) {
[17:29:04.920]                   name <- removed[[kk]]
[17:29:04.920]                   NAME <- NAMES[[kk]]
[17:29:04.920]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:04.920]                     next
[17:29:04.920]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:04.920]                 }
[17:29:04.920]                 if (length(args) > 0) 
[17:29:04.920]                   base::do.call(base::Sys.setenv, args = args)
[17:29:04.920]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:04.920]             }
[17:29:04.920]             else {
[17:29:04.920]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:04.920]             }
[17:29:04.920]             {
[17:29:04.920]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:04.920]                   0L) {
[17:29:04.920]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:04.920]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:04.920]                   base::options(opts)
[17:29:04.920]                 }
[17:29:04.920]                 {
[17:29:04.920]                   {
[17:29:04.920]                     NULL
[17:29:04.920]                     RNGkind("Mersenne-Twister")
[17:29:04.920]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:04.920]                       inherits = FALSE)
[17:29:04.920]                   }
[17:29:04.920]                   options(future.plan = NULL)
[17:29:04.920]                   if (is.na(NA_character_)) 
[17:29:04.920]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:04.920]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:04.920]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:04.920]                     .init = FALSE)
[17:29:04.920]                 }
[17:29:04.920]             }
[17:29:04.920]         }
[17:29:04.920]     })
[17:29:04.920]     if (TRUE) {
[17:29:04.920]         base::sink(type = "output", split = FALSE)
[17:29:04.920]         if (TRUE) {
[17:29:04.920]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:04.920]         }
[17:29:04.920]         else {
[17:29:04.920]             ...future.result["stdout"] <- base::list(NULL)
[17:29:04.920]         }
[17:29:04.920]         base::close(...future.stdout)
[17:29:04.920]         ...future.stdout <- NULL
[17:29:04.920]     }
[17:29:04.920]     ...future.result$conditions <- ...future.conditions
[17:29:04.920]     ...future.result$finished <- base::Sys.time()
[17:29:04.920]     ...future.result
[17:29:04.920] }
[17:29:04.927] assign_globals() ...
[17:29:04.927] List of 1
[17:29:04.927]  $ kk: int 1
[17:29:04.927]  - attr(*, "where")=List of 1
[17:29:04.927]   ..$ kk:<environment: R_EmptyEnv> 
[17:29:04.927]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:04.927]  - attr(*, "resolved")= logi FALSE
[17:29:04.927]  - attr(*, "total_size")= int 35
[17:29:04.927]  - attr(*, "already-done")= logi TRUE
[17:29:04.932] - copied 'kk' to environment
[17:29:04.932] assign_globals() ... done
[17:29:04.933] plan(): Setting new future strategy stack:
[17:29:04.933] List of future strategies:
[17:29:04.933] 1. sequential:
[17:29:04.933]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:04.933]    - tweaked: FALSE
[17:29:04.933]    - call: NULL
[17:29:04.934] plan(): nbrOfWorkers() = 1
[17:29:05.051] plan(): Setting new future strategy stack:
[17:29:05.051] List of future strategies:
[17:29:05.051] 1. sequential:
[17:29:05.051]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:05.051]    - tweaked: FALSE
[17:29:05.051]    - call: plan(strategy)
[17:29:05.053] plan(): nbrOfWorkers() = 1
[17:29:05.053] SequentialFuture started (and completed)
[17:29:05.054] - Launch lazy future ... done
[17:29:05.054] run() for 'SequentialFuture' ... done
[17:29:05.054] resolved() for 'SequentialFuture' ...
[17:29:05.055] - state: 'finished'
[17:29:05.055] - run: TRUE
[17:29:05.055] - result: 'FutureResult'
[17:29:05.055] resolved() for 'SequentialFuture' ... done
[17:29:05.056] Future #1
[17:29:05.056]  length: 2 (resolved future 1)
[17:29:05.056] run() for 'Future' ...
[17:29:05.057] - state: 'created'
[17:29:05.057] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:05.058] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:05.058] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:05.058]   - Field: 'label'
[17:29:05.059]   - Field: 'local'
[17:29:05.059]   - Field: 'owner'
[17:29:05.059]   - Field: 'envir'
[17:29:05.060]   - Field: 'packages'
[17:29:05.060]   - Field: 'gc'
[17:29:05.060]   - Field: 'conditions'
[17:29:05.061]   - Field: 'expr'
[17:29:05.061]   - Field: 'uuid'
[17:29:05.061]   - Field: 'seed'
[17:29:05.062]   - Field: 'version'
[17:29:05.062]   - Field: 'result'
[17:29:05.062]   - Field: 'asynchronous'
[17:29:05.063]   - Field: 'calls'
[17:29:05.063]   - Field: 'globals'
[17:29:05.063]   - Field: 'stdout'
[17:29:05.064]   - Field: 'earlySignal'
[17:29:05.064]   - Field: 'lazy'
[17:29:05.064]   - Field: 'state'
[17:29:05.064] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:05.065] - Launch lazy future ...
[17:29:05.065] Packages needed by the future expression (n = 0): <none>
[17:29:05.066] Packages needed by future strategies (n = 0): <none>
[17:29:05.067] {
[17:29:05.067]     {
[17:29:05.067]         {
[17:29:05.067]             ...future.startTime <- base::Sys.time()
[17:29:05.067]             {
[17:29:05.067]                 {
[17:29:05.067]                   {
[17:29:05.067]                     base::local({
[17:29:05.067]                       has_future <- base::requireNamespace("future", 
[17:29:05.067]                         quietly = TRUE)
[17:29:05.067]                       if (has_future) {
[17:29:05.067]                         ns <- base::getNamespace("future")
[17:29:05.067]                         version <- ns[[".package"]][["version"]]
[17:29:05.067]                         if (is.null(version)) 
[17:29:05.067]                           version <- utils::packageVersion("future")
[17:29:05.067]                       }
[17:29:05.067]                       else {
[17:29:05.067]                         version <- NULL
[17:29:05.067]                       }
[17:29:05.067]                       if (!has_future || version < "1.8.0") {
[17:29:05.067]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:05.067]                           "", base::R.version$version.string), 
[17:29:05.067]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:05.067]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:05.067]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:05.067]                             "release", "version")], collapse = " "), 
[17:29:05.067]                           hostname = base::Sys.info()[["nodename"]])
[17:29:05.067]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:05.067]                           info)
[17:29:05.067]                         info <- base::paste(info, collapse = "; ")
[17:29:05.067]                         if (!has_future) {
[17:29:05.067]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:05.067]                             info)
[17:29:05.067]                         }
[17:29:05.067]                         else {
[17:29:05.067]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:05.067]                             info, version)
[17:29:05.067]                         }
[17:29:05.067]                         base::stop(msg)
[17:29:05.067]                       }
[17:29:05.067]                     })
[17:29:05.067]                   }
[17:29:05.067]                   ...future.strategy.old <- future::plan("list")
[17:29:05.067]                   options(future.plan = NULL)
[17:29:05.067]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:05.067]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:05.067]                 }
[17:29:05.067]                 ...future.workdir <- getwd()
[17:29:05.067]             }
[17:29:05.067]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:05.067]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:05.067]         }
[17:29:05.067]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:05.067]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:05.067]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:05.067]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:05.067]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:05.067]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:05.067]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:05.067]             base::names(...future.oldOptions))
[17:29:05.067]     }
[17:29:05.067]     if (FALSE) {
[17:29:05.067]     }
[17:29:05.067]     else {
[17:29:05.067]         if (TRUE) {
[17:29:05.067]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:05.067]                 open = "w")
[17:29:05.067]         }
[17:29:05.067]         else {
[17:29:05.067]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:05.067]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:05.067]         }
[17:29:05.067]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:05.067]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:05.067]             base::sink(type = "output", split = FALSE)
[17:29:05.067]             base::close(...future.stdout)
[17:29:05.067]         }, add = TRUE)
[17:29:05.067]     }
[17:29:05.067]     ...future.frame <- base::sys.nframe()
[17:29:05.067]     ...future.conditions <- base::list()
[17:29:05.067]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:05.067]     if (FALSE) {
[17:29:05.067]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:05.067]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:05.067]     }
[17:29:05.067]     ...future.result <- base::tryCatch({
[17:29:05.067]         base::withCallingHandlers({
[17:29:05.067]             ...future.value <- base::withVisible(base::local({
[17:29:05.067]                 Sys.sleep(0.1)
[17:29:05.067]                 kk
[17:29:05.067]             }))
[17:29:05.067]             future::FutureResult(value = ...future.value$value, 
[17:29:05.067]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:05.067]                   ...future.rng), globalenv = if (FALSE) 
[17:29:05.067]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:05.067]                     ...future.globalenv.names))
[17:29:05.067]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:05.067]         }, condition = base::local({
[17:29:05.067]             c <- base::c
[17:29:05.067]             inherits <- base::inherits
[17:29:05.067]             invokeRestart <- base::invokeRestart
[17:29:05.067]             length <- base::length
[17:29:05.067]             list <- base::list
[17:29:05.067]             seq.int <- base::seq.int
[17:29:05.067]             signalCondition <- base::signalCondition
[17:29:05.067]             sys.calls <- base::sys.calls
[17:29:05.067]             `[[` <- base::`[[`
[17:29:05.067]             `+` <- base::`+`
[17:29:05.067]             `<<-` <- base::`<<-`
[17:29:05.067]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:05.067]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:05.067]                   3L)]
[17:29:05.067]             }
[17:29:05.067]             function(cond) {
[17:29:05.067]                 is_error <- inherits(cond, "error")
[17:29:05.067]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:05.067]                   NULL)
[17:29:05.067]                 if (is_error) {
[17:29:05.067]                   sessionInformation <- function() {
[17:29:05.067]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:05.067]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:05.067]                       search = base::search(), system = base::Sys.info())
[17:29:05.067]                   }
[17:29:05.067]                   ...future.conditions[[length(...future.conditions) + 
[17:29:05.067]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:05.067]                     cond$call), session = sessionInformation(), 
[17:29:05.067]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:05.067]                   signalCondition(cond)
[17:29:05.067]                 }
[17:29:05.067]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:05.067]                 "immediateCondition"))) {
[17:29:05.067]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:05.067]                   ...future.conditions[[length(...future.conditions) + 
[17:29:05.067]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:05.067]                   if (TRUE && !signal) {
[17:29:05.067]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:05.067]                     {
[17:29:05.067]                       inherits <- base::inherits
[17:29:05.067]                       invokeRestart <- base::invokeRestart
[17:29:05.067]                       is.null <- base::is.null
[17:29:05.067]                       muffled <- FALSE
[17:29:05.067]                       if (inherits(cond, "message")) {
[17:29:05.067]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:05.067]                         if (muffled) 
[17:29:05.067]                           invokeRestart("muffleMessage")
[17:29:05.067]                       }
[17:29:05.067]                       else if (inherits(cond, "warning")) {
[17:29:05.067]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:05.067]                         if (muffled) 
[17:29:05.067]                           invokeRestart("muffleWarning")
[17:29:05.067]                       }
[17:29:05.067]                       else if (inherits(cond, "condition")) {
[17:29:05.067]                         if (!is.null(pattern)) {
[17:29:05.067]                           computeRestarts <- base::computeRestarts
[17:29:05.067]                           grepl <- base::grepl
[17:29:05.067]                           restarts <- computeRestarts(cond)
[17:29:05.067]                           for (restart in restarts) {
[17:29:05.067]                             name <- restart$name
[17:29:05.067]                             if (is.null(name)) 
[17:29:05.067]                               next
[17:29:05.067]                             if (!grepl(pattern, name)) 
[17:29:05.067]                               next
[17:29:05.067]                             invokeRestart(restart)
[17:29:05.067]                             muffled <- TRUE
[17:29:05.067]                             break
[17:29:05.067]                           }
[17:29:05.067]                         }
[17:29:05.067]                       }
[17:29:05.067]                       invisible(muffled)
[17:29:05.067]                     }
[17:29:05.067]                     muffleCondition(cond, pattern = "^muffle")
[17:29:05.067]                   }
[17:29:05.067]                 }
[17:29:05.067]                 else {
[17:29:05.067]                   if (TRUE) {
[17:29:05.067]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:05.067]                     {
[17:29:05.067]                       inherits <- base::inherits
[17:29:05.067]                       invokeRestart <- base::invokeRestart
[17:29:05.067]                       is.null <- base::is.null
[17:29:05.067]                       muffled <- FALSE
[17:29:05.067]                       if (inherits(cond, "message")) {
[17:29:05.067]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:05.067]                         if (muffled) 
[17:29:05.067]                           invokeRestart("muffleMessage")
[17:29:05.067]                       }
[17:29:05.067]                       else if (inherits(cond, "warning")) {
[17:29:05.067]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:05.067]                         if (muffled) 
[17:29:05.067]                           invokeRestart("muffleWarning")
[17:29:05.067]                       }
[17:29:05.067]                       else if (inherits(cond, "condition")) {
[17:29:05.067]                         if (!is.null(pattern)) {
[17:29:05.067]                           computeRestarts <- base::computeRestarts
[17:29:05.067]                           grepl <- base::grepl
[17:29:05.067]                           restarts <- computeRestarts(cond)
[17:29:05.067]                           for (restart in restarts) {
[17:29:05.067]                             name <- restart$name
[17:29:05.067]                             if (is.null(name)) 
[17:29:05.067]                               next
[17:29:05.067]                             if (!grepl(pattern, name)) 
[17:29:05.067]                               next
[17:29:05.067]                             invokeRestart(restart)
[17:29:05.067]                             muffled <- TRUE
[17:29:05.067]                             break
[17:29:05.067]                           }
[17:29:05.067]                         }
[17:29:05.067]                       }
[17:29:05.067]                       invisible(muffled)
[17:29:05.067]                     }
[17:29:05.067]                     muffleCondition(cond, pattern = "^muffle")
[17:29:05.067]                   }
[17:29:05.067]                 }
[17:29:05.067]             }
[17:29:05.067]         }))
[17:29:05.067]     }, error = function(ex) {
[17:29:05.067]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:05.067]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:05.067]                 ...future.rng), started = ...future.startTime, 
[17:29:05.067]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:05.067]             version = "1.8"), class = "FutureResult")
[17:29:05.067]     }, finally = {
[17:29:05.067]         if (!identical(...future.workdir, getwd())) 
[17:29:05.067]             setwd(...future.workdir)
[17:29:05.067]         {
[17:29:05.067]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:05.067]                 ...future.oldOptions$nwarnings <- NULL
[17:29:05.067]             }
[17:29:05.067]             base::options(...future.oldOptions)
[17:29:05.067]             if (.Platform$OS.type == "windows") {
[17:29:05.067]                 old_names <- names(...future.oldEnvVars)
[17:29:05.067]                 envs <- base::Sys.getenv()
[17:29:05.067]                 names <- names(envs)
[17:29:05.067]                 common <- intersect(names, old_names)
[17:29:05.067]                 added <- setdiff(names, old_names)
[17:29:05.067]                 removed <- setdiff(old_names, names)
[17:29:05.067]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:05.067]                   envs[common]]
[17:29:05.067]                 NAMES <- toupper(changed)
[17:29:05.067]                 args <- list()
[17:29:05.067]                 for (kk in seq_along(NAMES)) {
[17:29:05.067]                   name <- changed[[kk]]
[17:29:05.067]                   NAME <- NAMES[[kk]]
[17:29:05.067]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.067]                     next
[17:29:05.067]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:05.067]                 }
[17:29:05.067]                 NAMES <- toupper(added)
[17:29:05.067]                 for (kk in seq_along(NAMES)) {
[17:29:05.067]                   name <- added[[kk]]
[17:29:05.067]                   NAME <- NAMES[[kk]]
[17:29:05.067]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.067]                     next
[17:29:05.067]                   args[[name]] <- ""
[17:29:05.067]                 }
[17:29:05.067]                 NAMES <- toupper(removed)
[17:29:05.067]                 for (kk in seq_along(NAMES)) {
[17:29:05.067]                   name <- removed[[kk]]
[17:29:05.067]                   NAME <- NAMES[[kk]]
[17:29:05.067]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.067]                     next
[17:29:05.067]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:05.067]                 }
[17:29:05.067]                 if (length(args) > 0) 
[17:29:05.067]                   base::do.call(base::Sys.setenv, args = args)
[17:29:05.067]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:05.067]             }
[17:29:05.067]             else {
[17:29:05.067]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:05.067]             }
[17:29:05.067]             {
[17:29:05.067]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:05.067]                   0L) {
[17:29:05.067]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:05.067]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:05.067]                   base::options(opts)
[17:29:05.067]                 }
[17:29:05.067]                 {
[17:29:05.067]                   {
[17:29:05.067]                     NULL
[17:29:05.067]                     RNGkind("Mersenne-Twister")
[17:29:05.067]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:05.067]                       inherits = FALSE)
[17:29:05.067]                   }
[17:29:05.067]                   options(future.plan = NULL)
[17:29:05.067]                   if (is.na(NA_character_)) 
[17:29:05.067]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:05.067]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:05.067]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:05.067]                     .init = FALSE)
[17:29:05.067]                 }
[17:29:05.067]             }
[17:29:05.067]         }
[17:29:05.067]     })
[17:29:05.067]     if (TRUE) {
[17:29:05.067]         base::sink(type = "output", split = FALSE)
[17:29:05.067]         if (TRUE) {
[17:29:05.067]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:05.067]         }
[17:29:05.067]         else {
[17:29:05.067]             ...future.result["stdout"] <- base::list(NULL)
[17:29:05.067]         }
[17:29:05.067]         base::close(...future.stdout)
[17:29:05.067]         ...future.stdout <- NULL
[17:29:05.067]     }
[17:29:05.067]     ...future.result$conditions <- ...future.conditions
[17:29:05.067]     ...future.result$finished <- base::Sys.time()
[17:29:05.067]     ...future.result
[17:29:05.067] }
[17:29:05.073] assign_globals() ...
[17:29:05.073] List of 1
[17:29:05.073]  $ kk: int 2
[17:29:05.073]  - attr(*, "where")=List of 1
[17:29:05.073]   ..$ kk:<environment: R_EmptyEnv> 
[17:29:05.073]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:05.073]  - attr(*, "resolved")= logi FALSE
[17:29:05.073]  - attr(*, "total_size")= int 35
[17:29:05.073]  - attr(*, "already-done")= logi TRUE
[17:29:05.078] - copied 'kk' to environment
[17:29:05.079] assign_globals() ... done
[17:29:05.079] plan(): Setting new future strategy stack:
[17:29:05.079] List of future strategies:
[17:29:05.079] 1. sequential:
[17:29:05.079]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:05.079]    - tweaked: FALSE
[17:29:05.079]    - call: NULL
[17:29:05.081] plan(): nbrOfWorkers() = 1
[17:29:05.192] plan(): Setting new future strategy stack:
[17:29:05.192] List of future strategies:
[17:29:05.192] 1. sequential:
[17:29:05.192]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:05.192]    - tweaked: FALSE
[17:29:05.192]    - call: plan(strategy)
[17:29:05.193] plan(): nbrOfWorkers() = 1
[17:29:05.194] SequentialFuture started (and completed)
[17:29:05.194] - Launch lazy future ... done
[17:29:05.195] run() for 'SequentialFuture' ... done
[17:29:05.195] resolved() for 'SequentialFuture' ...
[17:29:05.195] - state: 'finished'
[17:29:05.196] - run: TRUE
[17:29:05.196] - result: 'FutureResult'
[17:29:05.196] resolved() for 'SequentialFuture' ... done
[17:29:05.197] Future #2
[17:29:05.197]  length: 1 (resolved future 2)
[17:29:05.197] run() for 'Future' ...
[17:29:05.198] - state: 'created'
[17:29:05.198] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:05.199] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:05.199] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:05.200]   - Field: 'label'
[17:29:05.200]   - Field: 'local'
[17:29:05.200]   - Field: 'owner'
[17:29:05.201]   - Field: 'envir'
[17:29:05.201]   - Field: 'packages'
[17:29:05.201]   - Field: 'gc'
[17:29:05.204]   - Field: 'conditions'
[17:29:05.204]   - Field: 'expr'
[17:29:05.204]   - Field: 'uuid'
[17:29:05.205]   - Field: 'seed'
[17:29:05.205]   - Field: 'version'
[17:29:05.205]   - Field: 'result'
[17:29:05.205]   - Field: 'asynchronous'
[17:29:05.205]   - Field: 'calls'
[17:29:05.205]   - Field: 'globals'
[17:29:05.206]   - Field: 'stdout'
[17:29:05.206]   - Field: 'earlySignal'
[17:29:05.206]   - Field: 'lazy'
[17:29:05.206]   - Field: 'state'
[17:29:05.207] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:05.207] - Launch lazy future ...
[17:29:05.207] Packages needed by the future expression (n = 0): <none>
[17:29:05.208] Packages needed by future strategies (n = 0): <none>
[17:29:05.209] {
[17:29:05.209]     {
[17:29:05.209]         {
[17:29:05.209]             ...future.startTime <- base::Sys.time()
[17:29:05.209]             {
[17:29:05.209]                 {
[17:29:05.209]                   {
[17:29:05.209]                     base::local({
[17:29:05.209]                       has_future <- base::requireNamespace("future", 
[17:29:05.209]                         quietly = TRUE)
[17:29:05.209]                       if (has_future) {
[17:29:05.209]                         ns <- base::getNamespace("future")
[17:29:05.209]                         version <- ns[[".package"]][["version"]]
[17:29:05.209]                         if (is.null(version)) 
[17:29:05.209]                           version <- utils::packageVersion("future")
[17:29:05.209]                       }
[17:29:05.209]                       else {
[17:29:05.209]                         version <- NULL
[17:29:05.209]                       }
[17:29:05.209]                       if (!has_future || version < "1.8.0") {
[17:29:05.209]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:05.209]                           "", base::R.version$version.string), 
[17:29:05.209]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:05.209]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:05.209]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:05.209]                             "release", "version")], collapse = " "), 
[17:29:05.209]                           hostname = base::Sys.info()[["nodename"]])
[17:29:05.209]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:05.209]                           info)
[17:29:05.209]                         info <- base::paste(info, collapse = "; ")
[17:29:05.209]                         if (!has_future) {
[17:29:05.209]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:05.209]                             info)
[17:29:05.209]                         }
[17:29:05.209]                         else {
[17:29:05.209]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:05.209]                             info, version)
[17:29:05.209]                         }
[17:29:05.209]                         base::stop(msg)
[17:29:05.209]                       }
[17:29:05.209]                     })
[17:29:05.209]                   }
[17:29:05.209]                   ...future.strategy.old <- future::plan("list")
[17:29:05.209]                   options(future.plan = NULL)
[17:29:05.209]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:05.209]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:05.209]                 }
[17:29:05.209]                 ...future.workdir <- getwd()
[17:29:05.209]             }
[17:29:05.209]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:05.209]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:05.209]         }
[17:29:05.209]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:05.209]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:05.209]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:05.209]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:05.209]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:05.209]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:05.209]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:05.209]             base::names(...future.oldOptions))
[17:29:05.209]     }
[17:29:05.209]     if (FALSE) {
[17:29:05.209]     }
[17:29:05.209]     else {
[17:29:05.209]         if (TRUE) {
[17:29:05.209]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:05.209]                 open = "w")
[17:29:05.209]         }
[17:29:05.209]         else {
[17:29:05.209]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:05.209]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:05.209]         }
[17:29:05.209]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:05.209]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:05.209]             base::sink(type = "output", split = FALSE)
[17:29:05.209]             base::close(...future.stdout)
[17:29:05.209]         }, add = TRUE)
[17:29:05.209]     }
[17:29:05.209]     ...future.frame <- base::sys.nframe()
[17:29:05.209]     ...future.conditions <- base::list()
[17:29:05.209]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:05.209]     if (FALSE) {
[17:29:05.209]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:05.209]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:05.209]     }
[17:29:05.209]     ...future.result <- base::tryCatch({
[17:29:05.209]         base::withCallingHandlers({
[17:29:05.209]             ...future.value <- base::withVisible(base::local({
[17:29:05.209]                 Sys.sleep(0.1)
[17:29:05.209]                 kk
[17:29:05.209]             }))
[17:29:05.209]             future::FutureResult(value = ...future.value$value, 
[17:29:05.209]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:05.209]                   ...future.rng), globalenv = if (FALSE) 
[17:29:05.209]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:05.209]                     ...future.globalenv.names))
[17:29:05.209]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:05.209]         }, condition = base::local({
[17:29:05.209]             c <- base::c
[17:29:05.209]             inherits <- base::inherits
[17:29:05.209]             invokeRestart <- base::invokeRestart
[17:29:05.209]             length <- base::length
[17:29:05.209]             list <- base::list
[17:29:05.209]             seq.int <- base::seq.int
[17:29:05.209]             signalCondition <- base::signalCondition
[17:29:05.209]             sys.calls <- base::sys.calls
[17:29:05.209]             `[[` <- base::`[[`
[17:29:05.209]             `+` <- base::`+`
[17:29:05.209]             `<<-` <- base::`<<-`
[17:29:05.209]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:05.209]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:05.209]                   3L)]
[17:29:05.209]             }
[17:29:05.209]             function(cond) {
[17:29:05.209]                 is_error <- inherits(cond, "error")
[17:29:05.209]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:05.209]                   NULL)
[17:29:05.209]                 if (is_error) {
[17:29:05.209]                   sessionInformation <- function() {
[17:29:05.209]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:05.209]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:05.209]                       search = base::search(), system = base::Sys.info())
[17:29:05.209]                   }
[17:29:05.209]                   ...future.conditions[[length(...future.conditions) + 
[17:29:05.209]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:05.209]                     cond$call), session = sessionInformation(), 
[17:29:05.209]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:05.209]                   signalCondition(cond)
[17:29:05.209]                 }
[17:29:05.209]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:05.209]                 "immediateCondition"))) {
[17:29:05.209]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:05.209]                   ...future.conditions[[length(...future.conditions) + 
[17:29:05.209]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:05.209]                   if (TRUE && !signal) {
[17:29:05.209]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:05.209]                     {
[17:29:05.209]                       inherits <- base::inherits
[17:29:05.209]                       invokeRestart <- base::invokeRestart
[17:29:05.209]                       is.null <- base::is.null
[17:29:05.209]                       muffled <- FALSE
[17:29:05.209]                       if (inherits(cond, "message")) {
[17:29:05.209]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:05.209]                         if (muffled) 
[17:29:05.209]                           invokeRestart("muffleMessage")
[17:29:05.209]                       }
[17:29:05.209]                       else if (inherits(cond, "warning")) {
[17:29:05.209]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:05.209]                         if (muffled) 
[17:29:05.209]                           invokeRestart("muffleWarning")
[17:29:05.209]                       }
[17:29:05.209]                       else if (inherits(cond, "condition")) {
[17:29:05.209]                         if (!is.null(pattern)) {
[17:29:05.209]                           computeRestarts <- base::computeRestarts
[17:29:05.209]                           grepl <- base::grepl
[17:29:05.209]                           restarts <- computeRestarts(cond)
[17:29:05.209]                           for (restart in restarts) {
[17:29:05.209]                             name <- restart$name
[17:29:05.209]                             if (is.null(name)) 
[17:29:05.209]                               next
[17:29:05.209]                             if (!grepl(pattern, name)) 
[17:29:05.209]                               next
[17:29:05.209]                             invokeRestart(restart)
[17:29:05.209]                             muffled <- TRUE
[17:29:05.209]                             break
[17:29:05.209]                           }
[17:29:05.209]                         }
[17:29:05.209]                       }
[17:29:05.209]                       invisible(muffled)
[17:29:05.209]                     }
[17:29:05.209]                     muffleCondition(cond, pattern = "^muffle")
[17:29:05.209]                   }
[17:29:05.209]                 }
[17:29:05.209]                 else {
[17:29:05.209]                   if (TRUE) {
[17:29:05.209]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:05.209]                     {
[17:29:05.209]                       inherits <- base::inherits
[17:29:05.209]                       invokeRestart <- base::invokeRestart
[17:29:05.209]                       is.null <- base::is.null
[17:29:05.209]                       muffled <- FALSE
[17:29:05.209]                       if (inherits(cond, "message")) {
[17:29:05.209]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:05.209]                         if (muffled) 
[17:29:05.209]                           invokeRestart("muffleMessage")
[17:29:05.209]                       }
[17:29:05.209]                       else if (inherits(cond, "warning")) {
[17:29:05.209]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:05.209]                         if (muffled) 
[17:29:05.209]                           invokeRestart("muffleWarning")
[17:29:05.209]                       }
[17:29:05.209]                       else if (inherits(cond, "condition")) {
[17:29:05.209]                         if (!is.null(pattern)) {
[17:29:05.209]                           computeRestarts <- base::computeRestarts
[17:29:05.209]                           grepl <- base::grepl
[17:29:05.209]                           restarts <- computeRestarts(cond)
[17:29:05.209]                           for (restart in restarts) {
[17:29:05.209]                             name <- restart$name
[17:29:05.209]                             if (is.null(name)) 
[17:29:05.209]                               next
[17:29:05.209]                             if (!grepl(pattern, name)) 
[17:29:05.209]                               next
[17:29:05.209]                             invokeRestart(restart)
[17:29:05.209]                             muffled <- TRUE
[17:29:05.209]                             break
[17:29:05.209]                           }
[17:29:05.209]                         }
[17:29:05.209]                       }
[17:29:05.209]                       invisible(muffled)
[17:29:05.209]                     }
[17:29:05.209]                     muffleCondition(cond, pattern = "^muffle")
[17:29:05.209]                   }
[17:29:05.209]                 }
[17:29:05.209]             }
[17:29:05.209]         }))
[17:29:05.209]     }, error = function(ex) {
[17:29:05.209]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:05.209]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:05.209]                 ...future.rng), started = ...future.startTime, 
[17:29:05.209]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:05.209]             version = "1.8"), class = "FutureResult")
[17:29:05.209]     }, finally = {
[17:29:05.209]         if (!identical(...future.workdir, getwd())) 
[17:29:05.209]             setwd(...future.workdir)
[17:29:05.209]         {
[17:29:05.209]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:05.209]                 ...future.oldOptions$nwarnings <- NULL
[17:29:05.209]             }
[17:29:05.209]             base::options(...future.oldOptions)
[17:29:05.209]             if (.Platform$OS.type == "windows") {
[17:29:05.209]                 old_names <- names(...future.oldEnvVars)
[17:29:05.209]                 envs <- base::Sys.getenv()
[17:29:05.209]                 names <- names(envs)
[17:29:05.209]                 common <- intersect(names, old_names)
[17:29:05.209]                 added <- setdiff(names, old_names)
[17:29:05.209]                 removed <- setdiff(old_names, names)
[17:29:05.209]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:05.209]                   envs[common]]
[17:29:05.209]                 NAMES <- toupper(changed)
[17:29:05.209]                 args <- list()
[17:29:05.209]                 for (kk in seq_along(NAMES)) {
[17:29:05.209]                   name <- changed[[kk]]
[17:29:05.209]                   NAME <- NAMES[[kk]]
[17:29:05.209]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.209]                     next
[17:29:05.209]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:05.209]                 }
[17:29:05.209]                 NAMES <- toupper(added)
[17:29:05.209]                 for (kk in seq_along(NAMES)) {
[17:29:05.209]                   name <- added[[kk]]
[17:29:05.209]                   NAME <- NAMES[[kk]]
[17:29:05.209]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.209]                     next
[17:29:05.209]                   args[[name]] <- ""
[17:29:05.209]                 }
[17:29:05.209]                 NAMES <- toupper(removed)
[17:29:05.209]                 for (kk in seq_along(NAMES)) {
[17:29:05.209]                   name <- removed[[kk]]
[17:29:05.209]                   NAME <- NAMES[[kk]]
[17:29:05.209]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.209]                     next
[17:29:05.209]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:05.209]                 }
[17:29:05.209]                 if (length(args) > 0) 
[17:29:05.209]                   base::do.call(base::Sys.setenv, args = args)
[17:29:05.209]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:05.209]             }
[17:29:05.209]             else {
[17:29:05.209]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:05.209]             }
[17:29:05.209]             {
[17:29:05.209]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:05.209]                   0L) {
[17:29:05.209]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:05.209]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:05.209]                   base::options(opts)
[17:29:05.209]                 }
[17:29:05.209]                 {
[17:29:05.209]                   {
[17:29:05.209]                     NULL
[17:29:05.209]                     RNGkind("Mersenne-Twister")
[17:29:05.209]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:05.209]                       inherits = FALSE)
[17:29:05.209]                   }
[17:29:05.209]                   options(future.plan = NULL)
[17:29:05.209]                   if (is.na(NA_character_)) 
[17:29:05.209]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:05.209]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:05.209]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:05.209]                     .init = FALSE)
[17:29:05.209]                 }
[17:29:05.209]             }
[17:29:05.209]         }
[17:29:05.209]     })
[17:29:05.209]     if (TRUE) {
[17:29:05.209]         base::sink(type = "output", split = FALSE)
[17:29:05.209]         if (TRUE) {
[17:29:05.209]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:05.209]         }
[17:29:05.209]         else {
[17:29:05.209]             ...future.result["stdout"] <- base::list(NULL)
[17:29:05.209]         }
[17:29:05.209]         base::close(...future.stdout)
[17:29:05.209]         ...future.stdout <- NULL
[17:29:05.209]     }
[17:29:05.209]     ...future.result$conditions <- ...future.conditions
[17:29:05.209]     ...future.result$finished <- base::Sys.time()
[17:29:05.209]     ...future.result
[17:29:05.209] }
[17:29:05.214] assign_globals() ...
[17:29:05.214] List of 1
[17:29:05.214]  $ kk: int 3
[17:29:05.214]  - attr(*, "where")=List of 1
[17:29:05.214]   ..$ kk:<environment: R_EmptyEnv> 
[17:29:05.214]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:05.214]  - attr(*, "resolved")= logi FALSE
[17:29:05.214]  - attr(*, "total_size")= int 35
[17:29:05.214]  - attr(*, "already-done")= logi TRUE
[17:29:05.218] - copied 'kk' to environment
[17:29:05.218] assign_globals() ... done
[17:29:05.219] plan(): Setting new future strategy stack:
[17:29:05.219] List of future strategies:
[17:29:05.219] 1. sequential:
[17:29:05.219]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:05.219]    - tweaked: FALSE
[17:29:05.219]    - call: NULL
[17:29:05.220] plan(): nbrOfWorkers() = 1
[17:29:05.332] plan(): Setting new future strategy stack:
[17:29:05.333] List of future strategies:
[17:29:05.333] 1. sequential:
[17:29:05.333]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:05.333]    - tweaked: FALSE
[17:29:05.333]    - call: plan(strategy)
[17:29:05.334] plan(): nbrOfWorkers() = 1
[17:29:05.335] SequentialFuture started (and completed)
[17:29:05.335] - Launch lazy future ... done
[17:29:05.335] run() for 'SequentialFuture' ... done
[17:29:05.336] resolved() for 'SequentialFuture' ...
[17:29:05.336] - state: 'finished'
[17:29:05.337] - run: TRUE
[17:29:05.337] - result: 'FutureResult'
[17:29:05.337] resolved() for 'SequentialFuture' ... done
[17:29:05.338] Future #3
[17:29:05.338]  length: 0 (resolved future 3)
[17:29:05.339] resolve() on list ... DONE
*** resolve() for lists ... DONE
*** resolve() for environments ...
[17:29:05.341] resolve() on environment ...
[17:29:05.341]  recursive: 0
[17:29:05.343]  elements: [2] 'a', 'b'
[17:29:05.343]  length: 1 (resolved future 1)
[17:29:05.344]  length: 0 (resolved future 2)
[17:29:05.344] resolve() on environment ... DONE
[17:29:05.345] getGlobalsAndPackages() ...
[17:29:05.345] Searching for globals...
[17:29:05.346] 
[17:29:05.347] Searching for globals ... DONE
[17:29:05.347] - globals: [0] <none>
[17:29:05.347] getGlobalsAndPackages() ... DONE
[17:29:05.348] run() for 'Future' ...
[17:29:05.348] - state: 'created'
[17:29:05.349] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:05.350] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:05.350] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:05.350]   - Field: 'label'
[17:29:05.351]   - Field: 'local'
[17:29:05.351]   - Field: 'owner'
[17:29:05.352]   - Field: 'envir'
[17:29:05.352]   - Field: 'packages'
[17:29:05.352]   - Field: 'gc'
[17:29:05.353]   - Field: 'conditions'
[17:29:05.353]   - Field: 'expr'
[17:29:05.353]   - Field: 'uuid'
[17:29:05.354]   - Field: 'seed'
[17:29:05.354]   - Field: 'version'
[17:29:05.355]   - Field: 'result'
[17:29:05.355]   - Field: 'asynchronous'
[17:29:05.355]   - Field: 'calls'
[17:29:05.356]   - Field: 'globals'
[17:29:05.356]   - Field: 'stdout'
[17:29:05.356]   - Field: 'earlySignal'
[17:29:05.357]   - Field: 'lazy'
[17:29:05.357]   - Field: 'state'
[17:29:05.357] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:05.358] - Launch lazy future ...
[17:29:05.358] Packages needed by the future expression (n = 0): <none>
[17:29:05.359] Packages needed by future strategies (n = 0): <none>
[17:29:05.360] {
[17:29:05.360]     {
[17:29:05.360]         {
[17:29:05.360]             ...future.startTime <- base::Sys.time()
[17:29:05.360]             {
[17:29:05.360]                 {
[17:29:05.360]                   {
[17:29:05.360]                     base::local({
[17:29:05.360]                       has_future <- base::requireNamespace("future", 
[17:29:05.360]                         quietly = TRUE)
[17:29:05.360]                       if (has_future) {
[17:29:05.360]                         ns <- base::getNamespace("future")
[17:29:05.360]                         version <- ns[[".package"]][["version"]]
[17:29:05.360]                         if (is.null(version)) 
[17:29:05.360]                           version <- utils::packageVersion("future")
[17:29:05.360]                       }
[17:29:05.360]                       else {
[17:29:05.360]                         version <- NULL
[17:29:05.360]                       }
[17:29:05.360]                       if (!has_future || version < "1.8.0") {
[17:29:05.360]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:05.360]                           "", base::R.version$version.string), 
[17:29:05.360]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:05.360]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:05.360]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:05.360]                             "release", "version")], collapse = " "), 
[17:29:05.360]                           hostname = base::Sys.info()[["nodename"]])
[17:29:05.360]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:05.360]                           info)
[17:29:05.360]                         info <- base::paste(info, collapse = "; ")
[17:29:05.360]                         if (!has_future) {
[17:29:05.360]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:05.360]                             info)
[17:29:05.360]                         }
[17:29:05.360]                         else {
[17:29:05.360]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:05.360]                             info, version)
[17:29:05.360]                         }
[17:29:05.360]                         base::stop(msg)
[17:29:05.360]                       }
[17:29:05.360]                     })
[17:29:05.360]                   }
[17:29:05.360]                   ...future.strategy.old <- future::plan("list")
[17:29:05.360]                   options(future.plan = NULL)
[17:29:05.360]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:05.360]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:05.360]                 }
[17:29:05.360]                 ...future.workdir <- getwd()
[17:29:05.360]             }
[17:29:05.360]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:05.360]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:05.360]         }
[17:29:05.360]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:05.360]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:05.360]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:05.360]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:05.360]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:05.360]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:05.360]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:05.360]             base::names(...future.oldOptions))
[17:29:05.360]     }
[17:29:05.360]     if (FALSE) {
[17:29:05.360]     }
[17:29:05.360]     else {
[17:29:05.360]         if (TRUE) {
[17:29:05.360]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:05.360]                 open = "w")
[17:29:05.360]         }
[17:29:05.360]         else {
[17:29:05.360]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:05.360]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:05.360]         }
[17:29:05.360]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:05.360]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:05.360]             base::sink(type = "output", split = FALSE)
[17:29:05.360]             base::close(...future.stdout)
[17:29:05.360]         }, add = TRUE)
[17:29:05.360]     }
[17:29:05.360]     ...future.frame <- base::sys.nframe()
[17:29:05.360]     ...future.conditions <- base::list()
[17:29:05.360]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:05.360]     if (FALSE) {
[17:29:05.360]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:05.360]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:05.360]     }
[17:29:05.360]     ...future.result <- base::tryCatch({
[17:29:05.360]         base::withCallingHandlers({
[17:29:05.360]             ...future.value <- base::withVisible(base::local(1))
[17:29:05.360]             future::FutureResult(value = ...future.value$value, 
[17:29:05.360]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:05.360]                   ...future.rng), globalenv = if (FALSE) 
[17:29:05.360]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:05.360]                     ...future.globalenv.names))
[17:29:05.360]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:05.360]         }, condition = base::local({
[17:29:05.360]             c <- base::c
[17:29:05.360]             inherits <- base::inherits
[17:29:05.360]             invokeRestart <- base::invokeRestart
[17:29:05.360]             length <- base::length
[17:29:05.360]             list <- base::list
[17:29:05.360]             seq.int <- base::seq.int
[17:29:05.360]             signalCondition <- base::signalCondition
[17:29:05.360]             sys.calls <- base::sys.calls
[17:29:05.360]             `[[` <- base::`[[`
[17:29:05.360]             `+` <- base::`+`
[17:29:05.360]             `<<-` <- base::`<<-`
[17:29:05.360]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:05.360]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:05.360]                   3L)]
[17:29:05.360]             }
[17:29:05.360]             function(cond) {
[17:29:05.360]                 is_error <- inherits(cond, "error")
[17:29:05.360]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:05.360]                   NULL)
[17:29:05.360]                 if (is_error) {
[17:29:05.360]                   sessionInformation <- function() {
[17:29:05.360]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:05.360]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:05.360]                       search = base::search(), system = base::Sys.info())
[17:29:05.360]                   }
[17:29:05.360]                   ...future.conditions[[length(...future.conditions) + 
[17:29:05.360]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:05.360]                     cond$call), session = sessionInformation(), 
[17:29:05.360]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:05.360]                   signalCondition(cond)
[17:29:05.360]                 }
[17:29:05.360]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:05.360]                 "immediateCondition"))) {
[17:29:05.360]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:05.360]                   ...future.conditions[[length(...future.conditions) + 
[17:29:05.360]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:05.360]                   if (TRUE && !signal) {
[17:29:05.360]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:05.360]                     {
[17:29:05.360]                       inherits <- base::inherits
[17:29:05.360]                       invokeRestart <- base::invokeRestart
[17:29:05.360]                       is.null <- base::is.null
[17:29:05.360]                       muffled <- FALSE
[17:29:05.360]                       if (inherits(cond, "message")) {
[17:29:05.360]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:05.360]                         if (muffled) 
[17:29:05.360]                           invokeRestart("muffleMessage")
[17:29:05.360]                       }
[17:29:05.360]                       else if (inherits(cond, "warning")) {
[17:29:05.360]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:05.360]                         if (muffled) 
[17:29:05.360]                           invokeRestart("muffleWarning")
[17:29:05.360]                       }
[17:29:05.360]                       else if (inherits(cond, "condition")) {
[17:29:05.360]                         if (!is.null(pattern)) {
[17:29:05.360]                           computeRestarts <- base::computeRestarts
[17:29:05.360]                           grepl <- base::grepl
[17:29:05.360]                           restarts <- computeRestarts(cond)
[17:29:05.360]                           for (restart in restarts) {
[17:29:05.360]                             name <- restart$name
[17:29:05.360]                             if (is.null(name)) 
[17:29:05.360]                               next
[17:29:05.360]                             if (!grepl(pattern, name)) 
[17:29:05.360]                               next
[17:29:05.360]                             invokeRestart(restart)
[17:29:05.360]                             muffled <- TRUE
[17:29:05.360]                             break
[17:29:05.360]                           }
[17:29:05.360]                         }
[17:29:05.360]                       }
[17:29:05.360]                       invisible(muffled)
[17:29:05.360]                     }
[17:29:05.360]                     muffleCondition(cond, pattern = "^muffle")
[17:29:05.360]                   }
[17:29:05.360]                 }
[17:29:05.360]                 else {
[17:29:05.360]                   if (TRUE) {
[17:29:05.360]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:05.360]                     {
[17:29:05.360]                       inherits <- base::inherits
[17:29:05.360]                       invokeRestart <- base::invokeRestart
[17:29:05.360]                       is.null <- base::is.null
[17:29:05.360]                       muffled <- FALSE
[17:29:05.360]                       if (inherits(cond, "message")) {
[17:29:05.360]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:05.360]                         if (muffled) 
[17:29:05.360]                           invokeRestart("muffleMessage")
[17:29:05.360]                       }
[17:29:05.360]                       else if (inherits(cond, "warning")) {
[17:29:05.360]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:05.360]                         if (muffled) 
[17:29:05.360]                           invokeRestart("muffleWarning")
[17:29:05.360]                       }
[17:29:05.360]                       else if (inherits(cond, "condition")) {
[17:29:05.360]                         if (!is.null(pattern)) {
[17:29:05.360]                           computeRestarts <- base::computeRestarts
[17:29:05.360]                           grepl <- base::grepl
[17:29:05.360]                           restarts <- computeRestarts(cond)
[17:29:05.360]                           for (restart in restarts) {
[17:29:05.360]                             name <- restart$name
[17:29:05.360]                             if (is.null(name)) 
[17:29:05.360]                               next
[17:29:05.360]                             if (!grepl(pattern, name)) 
[17:29:05.360]                               next
[17:29:05.360]                             invokeRestart(restart)
[17:29:05.360]                             muffled <- TRUE
[17:29:05.360]                             break
[17:29:05.360]                           }
[17:29:05.360]                         }
[17:29:05.360]                       }
[17:29:05.360]                       invisible(muffled)
[17:29:05.360]                     }
[17:29:05.360]                     muffleCondition(cond, pattern = "^muffle")
[17:29:05.360]                   }
[17:29:05.360]                 }
[17:29:05.360]             }
[17:29:05.360]         }))
[17:29:05.360]     }, error = function(ex) {
[17:29:05.360]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:05.360]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:05.360]                 ...future.rng), started = ...future.startTime, 
[17:29:05.360]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:05.360]             version = "1.8"), class = "FutureResult")
[17:29:05.360]     }, finally = {
[17:29:05.360]         if (!identical(...future.workdir, getwd())) 
[17:29:05.360]             setwd(...future.workdir)
[17:29:05.360]         {
[17:29:05.360]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:05.360]                 ...future.oldOptions$nwarnings <- NULL
[17:29:05.360]             }
[17:29:05.360]             base::options(...future.oldOptions)
[17:29:05.360]             if (.Platform$OS.type == "windows") {
[17:29:05.360]                 old_names <- names(...future.oldEnvVars)
[17:29:05.360]                 envs <- base::Sys.getenv()
[17:29:05.360]                 names <- names(envs)
[17:29:05.360]                 common <- intersect(names, old_names)
[17:29:05.360]                 added <- setdiff(names, old_names)
[17:29:05.360]                 removed <- setdiff(old_names, names)
[17:29:05.360]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:05.360]                   envs[common]]
[17:29:05.360]                 NAMES <- toupper(changed)
[17:29:05.360]                 args <- list()
[17:29:05.360]                 for (kk in seq_along(NAMES)) {
[17:29:05.360]                   name <- changed[[kk]]
[17:29:05.360]                   NAME <- NAMES[[kk]]
[17:29:05.360]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.360]                     next
[17:29:05.360]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:05.360]                 }
[17:29:05.360]                 NAMES <- toupper(added)
[17:29:05.360]                 for (kk in seq_along(NAMES)) {
[17:29:05.360]                   name <- added[[kk]]
[17:29:05.360]                   NAME <- NAMES[[kk]]
[17:29:05.360]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.360]                     next
[17:29:05.360]                   args[[name]] <- ""
[17:29:05.360]                 }
[17:29:05.360]                 NAMES <- toupper(removed)
[17:29:05.360]                 for (kk in seq_along(NAMES)) {
[17:29:05.360]                   name <- removed[[kk]]
[17:29:05.360]                   NAME <- NAMES[[kk]]
[17:29:05.360]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.360]                     next
[17:29:05.360]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:05.360]                 }
[17:29:05.360]                 if (length(args) > 0) 
[17:29:05.360]                   base::do.call(base::Sys.setenv, args = args)
[17:29:05.360]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:05.360]             }
[17:29:05.360]             else {
[17:29:05.360]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:05.360]             }
[17:29:05.360]             {
[17:29:05.360]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:05.360]                   0L) {
[17:29:05.360]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:05.360]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:05.360]                   base::options(opts)
[17:29:05.360]                 }
[17:29:05.360]                 {
[17:29:05.360]                   {
[17:29:05.360]                     NULL
[17:29:05.360]                     RNGkind("Mersenne-Twister")
[17:29:05.360]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:05.360]                       inherits = FALSE)
[17:29:05.360]                   }
[17:29:05.360]                   options(future.plan = NULL)
[17:29:05.360]                   if (is.na(NA_character_)) 
[17:29:05.360]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:05.360]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:05.360]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:05.360]                     .init = FALSE)
[17:29:05.360]                 }
[17:29:05.360]             }
[17:29:05.360]         }
[17:29:05.360]     })
[17:29:05.360]     if (TRUE) {
[17:29:05.360]         base::sink(type = "output", split = FALSE)
[17:29:05.360]         if (TRUE) {
[17:29:05.360]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:05.360]         }
[17:29:05.360]         else {
[17:29:05.360]             ...future.result["stdout"] <- base::list(NULL)
[17:29:05.360]         }
[17:29:05.360]         base::close(...future.stdout)
[17:29:05.360]         ...future.stdout <- NULL
[17:29:05.360]     }
[17:29:05.360]     ...future.result$conditions <- ...future.conditions
[17:29:05.360]     ...future.result$finished <- base::Sys.time()
[17:29:05.360]     ...future.result
[17:29:05.360] }
[17:29:05.367] plan(): Setting new future strategy stack:
[17:29:05.367] List of future strategies:
[17:29:05.367] 1. sequential:
[17:29:05.367]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:05.367]    - tweaked: FALSE
[17:29:05.367]    - call: NULL
[17:29:05.368] plan(): nbrOfWorkers() = 1
[17:29:05.370] plan(): Setting new future strategy stack:
[17:29:05.370] List of future strategies:
[17:29:05.370] 1. sequential:
[17:29:05.370]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:05.370]    - tweaked: FALSE
[17:29:05.370]    - call: plan(strategy)
[17:29:05.371] plan(): nbrOfWorkers() = 1
[17:29:05.371] SequentialFuture started (and completed)
[17:29:05.372] - Launch lazy future ... done
[17:29:05.372] run() for 'SequentialFuture' ... done
[17:29:05.375] getGlobalsAndPackages() ...
[17:29:05.375] Searching for globals...
[17:29:05.376] 
[17:29:05.376] Searching for globals ... DONE
[17:29:05.377] - globals: [0] <none>
[17:29:05.377] getGlobalsAndPackages() ... DONE
[17:29:05.378] run() for 'Future' ...
[17:29:05.378] - state: 'created'
[17:29:05.378] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:05.378] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:05.379] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:05.379]   - Field: 'label'
[17:29:05.379]   - Field: 'local'
[17:29:05.379]   - Field: 'owner'
[17:29:05.379]   - Field: 'envir'
[17:29:05.380]   - Field: 'packages'
[17:29:05.380]   - Field: 'gc'
[17:29:05.380]   - Field: 'conditions'
[17:29:05.380]   - Field: 'expr'
[17:29:05.380]   - Field: 'uuid'
[17:29:05.381]   - Field: 'seed'
[17:29:05.381]   - Field: 'version'
[17:29:05.381]   - Field: 'result'
[17:29:05.381]   - Field: 'asynchronous'
[17:29:05.381]   - Field: 'calls'
[17:29:05.381]   - Field: 'globals'
[17:29:05.382]   - Field: 'stdout'
[17:29:05.382]   - Field: 'earlySignal'
[17:29:05.382]   - Field: 'lazy'
[17:29:05.382]   - Field: 'state'
[17:29:05.382] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:05.382] - Launch lazy future ...
[17:29:05.383] Packages needed by the future expression (n = 0): <none>
[17:29:05.383] Packages needed by future strategies (n = 0): <none>
[17:29:05.384] {
[17:29:05.384]     {
[17:29:05.384]         {
[17:29:05.384]             ...future.startTime <- base::Sys.time()
[17:29:05.384]             {
[17:29:05.384]                 {
[17:29:05.384]                   {
[17:29:05.384]                     base::local({
[17:29:05.384]                       has_future <- base::requireNamespace("future", 
[17:29:05.384]                         quietly = TRUE)
[17:29:05.384]                       if (has_future) {
[17:29:05.384]                         ns <- base::getNamespace("future")
[17:29:05.384]                         version <- ns[[".package"]][["version"]]
[17:29:05.384]                         if (is.null(version)) 
[17:29:05.384]                           version <- utils::packageVersion("future")
[17:29:05.384]                       }
[17:29:05.384]                       else {
[17:29:05.384]                         version <- NULL
[17:29:05.384]                       }
[17:29:05.384]                       if (!has_future || version < "1.8.0") {
[17:29:05.384]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:05.384]                           "", base::R.version$version.string), 
[17:29:05.384]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:05.384]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:05.384]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:05.384]                             "release", "version")], collapse = " "), 
[17:29:05.384]                           hostname = base::Sys.info()[["nodename"]])
[17:29:05.384]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:05.384]                           info)
[17:29:05.384]                         info <- base::paste(info, collapse = "; ")
[17:29:05.384]                         if (!has_future) {
[17:29:05.384]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:05.384]                             info)
[17:29:05.384]                         }
[17:29:05.384]                         else {
[17:29:05.384]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:05.384]                             info, version)
[17:29:05.384]                         }
[17:29:05.384]                         base::stop(msg)
[17:29:05.384]                       }
[17:29:05.384]                     })
[17:29:05.384]                   }
[17:29:05.384]                   ...future.strategy.old <- future::plan("list")
[17:29:05.384]                   options(future.plan = NULL)
[17:29:05.384]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:05.384]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:05.384]                 }
[17:29:05.384]                 ...future.workdir <- getwd()
[17:29:05.384]             }
[17:29:05.384]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:05.384]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:05.384]         }
[17:29:05.384]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:05.384]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:05.384]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:05.384]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:05.384]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:05.384]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:05.384]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:05.384]             base::names(...future.oldOptions))
[17:29:05.384]     }
[17:29:05.384]     if (FALSE) {
[17:29:05.384]     }
[17:29:05.384]     else {
[17:29:05.384]         if (TRUE) {
[17:29:05.384]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:05.384]                 open = "w")
[17:29:05.384]         }
[17:29:05.384]         else {
[17:29:05.384]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:05.384]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:05.384]         }
[17:29:05.384]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:05.384]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:05.384]             base::sink(type = "output", split = FALSE)
[17:29:05.384]             base::close(...future.stdout)
[17:29:05.384]         }, add = TRUE)
[17:29:05.384]     }
[17:29:05.384]     ...future.frame <- base::sys.nframe()
[17:29:05.384]     ...future.conditions <- base::list()
[17:29:05.384]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:05.384]     if (FALSE) {
[17:29:05.384]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:05.384]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:05.384]     }
[17:29:05.384]     ...future.result <- base::tryCatch({
[17:29:05.384]         base::withCallingHandlers({
[17:29:05.384]             ...future.value <- base::withVisible(base::local(2))
[17:29:05.384]             future::FutureResult(value = ...future.value$value, 
[17:29:05.384]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:05.384]                   ...future.rng), globalenv = if (FALSE) 
[17:29:05.384]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:05.384]                     ...future.globalenv.names))
[17:29:05.384]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:05.384]         }, condition = base::local({
[17:29:05.384]             c <- base::c
[17:29:05.384]             inherits <- base::inherits
[17:29:05.384]             invokeRestart <- base::invokeRestart
[17:29:05.384]             length <- base::length
[17:29:05.384]             list <- base::list
[17:29:05.384]             seq.int <- base::seq.int
[17:29:05.384]             signalCondition <- base::signalCondition
[17:29:05.384]             sys.calls <- base::sys.calls
[17:29:05.384]             `[[` <- base::`[[`
[17:29:05.384]             `+` <- base::`+`
[17:29:05.384]             `<<-` <- base::`<<-`
[17:29:05.384]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:05.384]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:05.384]                   3L)]
[17:29:05.384]             }
[17:29:05.384]             function(cond) {
[17:29:05.384]                 is_error <- inherits(cond, "error")
[17:29:05.384]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:05.384]                   NULL)
[17:29:05.384]                 if (is_error) {
[17:29:05.384]                   sessionInformation <- function() {
[17:29:05.384]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:05.384]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:05.384]                       search = base::search(), system = base::Sys.info())
[17:29:05.384]                   }
[17:29:05.384]                   ...future.conditions[[length(...future.conditions) + 
[17:29:05.384]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:05.384]                     cond$call), session = sessionInformation(), 
[17:29:05.384]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:05.384]                   signalCondition(cond)
[17:29:05.384]                 }
[17:29:05.384]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:05.384]                 "immediateCondition"))) {
[17:29:05.384]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:05.384]                   ...future.conditions[[length(...future.conditions) + 
[17:29:05.384]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:05.384]                   if (TRUE && !signal) {
[17:29:05.384]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:05.384]                     {
[17:29:05.384]                       inherits <- base::inherits
[17:29:05.384]                       invokeRestart <- base::invokeRestart
[17:29:05.384]                       is.null <- base::is.null
[17:29:05.384]                       muffled <- FALSE
[17:29:05.384]                       if (inherits(cond, "message")) {
[17:29:05.384]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:05.384]                         if (muffled) 
[17:29:05.384]                           invokeRestart("muffleMessage")
[17:29:05.384]                       }
[17:29:05.384]                       else if (inherits(cond, "warning")) {
[17:29:05.384]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:05.384]                         if (muffled) 
[17:29:05.384]                           invokeRestart("muffleWarning")
[17:29:05.384]                       }
[17:29:05.384]                       else if (inherits(cond, "condition")) {
[17:29:05.384]                         if (!is.null(pattern)) {
[17:29:05.384]                           computeRestarts <- base::computeRestarts
[17:29:05.384]                           grepl <- base::grepl
[17:29:05.384]                           restarts <- computeRestarts(cond)
[17:29:05.384]                           for (restart in restarts) {
[17:29:05.384]                             name <- restart$name
[17:29:05.384]                             if (is.null(name)) 
[17:29:05.384]                               next
[17:29:05.384]                             if (!grepl(pattern, name)) 
[17:29:05.384]                               next
[17:29:05.384]                             invokeRestart(restart)
[17:29:05.384]                             muffled <- TRUE
[17:29:05.384]                             break
[17:29:05.384]                           }
[17:29:05.384]                         }
[17:29:05.384]                       }
[17:29:05.384]                       invisible(muffled)
[17:29:05.384]                     }
[17:29:05.384]                     muffleCondition(cond, pattern = "^muffle")
[17:29:05.384]                   }
[17:29:05.384]                 }
[17:29:05.384]                 else {
[17:29:05.384]                   if (TRUE) {
[17:29:05.384]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:05.384]                     {
[17:29:05.384]                       inherits <- base::inherits
[17:29:05.384]                       invokeRestart <- base::invokeRestart
[17:29:05.384]                       is.null <- base::is.null
[17:29:05.384]                       muffled <- FALSE
[17:29:05.384]                       if (inherits(cond, "message")) {
[17:29:05.384]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:05.384]                         if (muffled) 
[17:29:05.384]                           invokeRestart("muffleMessage")
[17:29:05.384]                       }
[17:29:05.384]                       else if (inherits(cond, "warning")) {
[17:29:05.384]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:05.384]                         if (muffled) 
[17:29:05.384]                           invokeRestart("muffleWarning")
[17:29:05.384]                       }
[17:29:05.384]                       else if (inherits(cond, "condition")) {
[17:29:05.384]                         if (!is.null(pattern)) {
[17:29:05.384]                           computeRestarts <- base::computeRestarts
[17:29:05.384]                           grepl <- base::grepl
[17:29:05.384]                           restarts <- computeRestarts(cond)
[17:29:05.384]                           for (restart in restarts) {
[17:29:05.384]                             name <- restart$name
[17:29:05.384]                             if (is.null(name)) 
[17:29:05.384]                               next
[17:29:05.384]                             if (!grepl(pattern, name)) 
[17:29:05.384]                               next
[17:29:05.384]                             invokeRestart(restart)
[17:29:05.384]                             muffled <- TRUE
[17:29:05.384]                             break
[17:29:05.384]                           }
[17:29:05.384]                         }
[17:29:05.384]                       }
[17:29:05.384]                       invisible(muffled)
[17:29:05.384]                     }
[17:29:05.384]                     muffleCondition(cond, pattern = "^muffle")
[17:29:05.384]                   }
[17:29:05.384]                 }
[17:29:05.384]             }
[17:29:05.384]         }))
[17:29:05.384]     }, error = function(ex) {
[17:29:05.384]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:05.384]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:05.384]                 ...future.rng), started = ...future.startTime, 
[17:29:05.384]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:05.384]             version = "1.8"), class = "FutureResult")
[17:29:05.384]     }, finally = {
[17:29:05.384]         if (!identical(...future.workdir, getwd())) 
[17:29:05.384]             setwd(...future.workdir)
[17:29:05.384]         {
[17:29:05.384]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:05.384]                 ...future.oldOptions$nwarnings <- NULL
[17:29:05.384]             }
[17:29:05.384]             base::options(...future.oldOptions)
[17:29:05.384]             if (.Platform$OS.type == "windows") {
[17:29:05.384]                 old_names <- names(...future.oldEnvVars)
[17:29:05.384]                 envs <- base::Sys.getenv()
[17:29:05.384]                 names <- names(envs)
[17:29:05.384]                 common <- intersect(names, old_names)
[17:29:05.384]                 added <- setdiff(names, old_names)
[17:29:05.384]                 removed <- setdiff(old_names, names)
[17:29:05.384]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:05.384]                   envs[common]]
[17:29:05.384]                 NAMES <- toupper(changed)
[17:29:05.384]                 args <- list()
[17:29:05.384]                 for (kk in seq_along(NAMES)) {
[17:29:05.384]                   name <- changed[[kk]]
[17:29:05.384]                   NAME <- NAMES[[kk]]
[17:29:05.384]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.384]                     next
[17:29:05.384]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:05.384]                 }
[17:29:05.384]                 NAMES <- toupper(added)
[17:29:05.384]                 for (kk in seq_along(NAMES)) {
[17:29:05.384]                   name <- added[[kk]]
[17:29:05.384]                   NAME <- NAMES[[kk]]
[17:29:05.384]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.384]                     next
[17:29:05.384]                   args[[name]] <- ""
[17:29:05.384]                 }
[17:29:05.384]                 NAMES <- toupper(removed)
[17:29:05.384]                 for (kk in seq_along(NAMES)) {
[17:29:05.384]                   name <- removed[[kk]]
[17:29:05.384]                   NAME <- NAMES[[kk]]
[17:29:05.384]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.384]                     next
[17:29:05.384]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:05.384]                 }
[17:29:05.384]                 if (length(args) > 0) 
[17:29:05.384]                   base::do.call(base::Sys.setenv, args = args)
[17:29:05.384]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:05.384]             }
[17:29:05.384]             else {
[17:29:05.384]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:05.384]             }
[17:29:05.384]             {
[17:29:05.384]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:05.384]                   0L) {
[17:29:05.384]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:05.384]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:05.384]                   base::options(opts)
[17:29:05.384]                 }
[17:29:05.384]                 {
[17:29:05.384]                   {
[17:29:05.384]                     NULL
[17:29:05.384]                     RNGkind("Mersenne-Twister")
[17:29:05.384]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:05.384]                       inherits = FALSE)
[17:29:05.384]                   }
[17:29:05.384]                   options(future.plan = NULL)
[17:29:05.384]                   if (is.na(NA_character_)) 
[17:29:05.384]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:05.384]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:05.384]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:05.384]                     .init = FALSE)
[17:29:05.384]                 }
[17:29:05.384]             }
[17:29:05.384]         }
[17:29:05.384]     })
[17:29:05.384]     if (TRUE) {
[17:29:05.384]         base::sink(type = "output", split = FALSE)
[17:29:05.384]         if (TRUE) {
[17:29:05.384]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:05.384]         }
[17:29:05.384]         else {
[17:29:05.384]             ...future.result["stdout"] <- base::list(NULL)
[17:29:05.384]         }
[17:29:05.384]         base::close(...future.stdout)
[17:29:05.384]         ...future.stdout <- NULL
[17:29:05.384]     }
[17:29:05.384]     ...future.result$conditions <- ...future.conditions
[17:29:05.384]     ...future.result$finished <- base::Sys.time()
[17:29:05.384]     ...future.result
[17:29:05.384] }
[17:29:05.388] plan(): Setting new future strategy stack:
[17:29:05.388] List of future strategies:
[17:29:05.388] 1. sequential:
[17:29:05.388]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:05.388]    - tweaked: FALSE
[17:29:05.388]    - call: NULL
[17:29:05.389] plan(): nbrOfWorkers() = 1
[17:29:05.390] plan(): Setting new future strategy stack:
[17:29:05.390] List of future strategies:
[17:29:05.390] 1. sequential:
[17:29:05.390]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:05.390]    - tweaked: FALSE
[17:29:05.390]    - call: plan(strategy)
[17:29:05.391] plan(): nbrOfWorkers() = 1
[17:29:05.391] SequentialFuture started (and completed)
[17:29:05.391] - Launch lazy future ... done
[17:29:05.392] run() for 'SequentialFuture' ... done
[17:29:05.392] resolve() on environment ...
[17:29:05.393]  recursive: 0
[17:29:05.393]  elements: [3] 'a', 'b', 'c'
[17:29:05.394] resolved() for 'SequentialFuture' ...
[17:29:05.394] - state: 'finished'
[17:29:05.394] - run: TRUE
[17:29:05.394] - result: 'FutureResult'
[17:29:05.395] resolved() for 'SequentialFuture' ... done
[17:29:05.395] Future #1
[17:29:05.395]  length: 2 (resolved future 1)
[17:29:05.395] resolved() for 'SequentialFuture' ...
[17:29:05.395] - state: 'finished'
[17:29:05.396] - run: TRUE
[17:29:05.396] - result: 'FutureResult'
[17:29:05.396] resolved() for 'SequentialFuture' ... done
[17:29:05.396] Future #2
[17:29:05.396]  length: 1 (resolved future 2)
[17:29:05.397]  length: 0 (resolved future 3)
[17:29:05.397] resolve() on environment ... DONE
[17:29:05.397] resolved() for 'SequentialFuture' ...
[17:29:05.397] - state: 'finished'
[17:29:05.397] - run: TRUE
[17:29:05.397] - result: 'FutureResult'
[17:29:05.398] resolved() for 'SequentialFuture' ... done
[17:29:05.398] resolved() for 'SequentialFuture' ...
[17:29:05.398] - state: 'finished'
[17:29:05.398] - run: TRUE
[17:29:05.398] - result: 'FutureResult'
[17:29:05.399] resolved() for 'SequentialFuture' ... done
[17:29:05.400] getGlobalsAndPackages() ...
[17:29:05.400] Searching for globals...
[17:29:05.401] - globals found: [1] '{'
[17:29:05.401] Searching for globals ... DONE
[17:29:05.401] Resolving globals: FALSE
[17:29:05.401] 
[17:29:05.402] 
[17:29:05.402] getGlobalsAndPackages() ... DONE
[17:29:05.402] run() for 'Future' ...
[17:29:05.402] - state: 'created'
[17:29:05.402] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:05.403] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:05.403] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:05.403]   - Field: 'label'
[17:29:05.403]   - Field: 'local'
[17:29:05.404]   - Field: 'owner'
[17:29:05.404]   - Field: 'envir'
[17:29:05.404]   - Field: 'packages'
[17:29:05.404]   - Field: 'gc'
[17:29:05.404]   - Field: 'conditions'
[17:29:05.405]   - Field: 'expr'
[17:29:05.405]   - Field: 'uuid'
[17:29:05.405]   - Field: 'seed'
[17:29:05.405]   - Field: 'version'
[17:29:05.405]   - Field: 'result'
[17:29:05.405]   - Field: 'asynchronous'
[17:29:05.406]   - Field: 'calls'
[17:29:05.406]   - Field: 'globals'
[17:29:05.406]   - Field: 'stdout'
[17:29:05.406]   - Field: 'earlySignal'
[17:29:05.406]   - Field: 'lazy'
[17:29:05.406]   - Field: 'state'
[17:29:05.407] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:05.407] - Launch lazy future ...
[17:29:05.407] Packages needed by the future expression (n = 0): <none>
[17:29:05.407] Packages needed by future strategies (n = 0): <none>
[17:29:05.408] {
[17:29:05.408]     {
[17:29:05.408]         {
[17:29:05.408]             ...future.startTime <- base::Sys.time()
[17:29:05.408]             {
[17:29:05.408]                 {
[17:29:05.408]                   {
[17:29:05.408]                     base::local({
[17:29:05.408]                       has_future <- base::requireNamespace("future", 
[17:29:05.408]                         quietly = TRUE)
[17:29:05.408]                       if (has_future) {
[17:29:05.408]                         ns <- base::getNamespace("future")
[17:29:05.408]                         version <- ns[[".package"]][["version"]]
[17:29:05.408]                         if (is.null(version)) 
[17:29:05.408]                           version <- utils::packageVersion("future")
[17:29:05.408]                       }
[17:29:05.408]                       else {
[17:29:05.408]                         version <- NULL
[17:29:05.408]                       }
[17:29:05.408]                       if (!has_future || version < "1.8.0") {
[17:29:05.408]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:05.408]                           "", base::R.version$version.string), 
[17:29:05.408]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:05.408]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:05.408]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:05.408]                             "release", "version")], collapse = " "), 
[17:29:05.408]                           hostname = base::Sys.info()[["nodename"]])
[17:29:05.408]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:05.408]                           info)
[17:29:05.408]                         info <- base::paste(info, collapse = "; ")
[17:29:05.408]                         if (!has_future) {
[17:29:05.408]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:05.408]                             info)
[17:29:05.408]                         }
[17:29:05.408]                         else {
[17:29:05.408]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:05.408]                             info, version)
[17:29:05.408]                         }
[17:29:05.408]                         base::stop(msg)
[17:29:05.408]                       }
[17:29:05.408]                     })
[17:29:05.408]                   }
[17:29:05.408]                   ...future.strategy.old <- future::plan("list")
[17:29:05.408]                   options(future.plan = NULL)
[17:29:05.408]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:05.408]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:05.408]                 }
[17:29:05.408]                 ...future.workdir <- getwd()
[17:29:05.408]             }
[17:29:05.408]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:05.408]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:05.408]         }
[17:29:05.408]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:05.408]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:05.408]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:05.408]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:05.408]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:05.408]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:05.408]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:05.408]             base::names(...future.oldOptions))
[17:29:05.408]     }
[17:29:05.408]     if (FALSE) {
[17:29:05.408]     }
[17:29:05.408]     else {
[17:29:05.408]         if (TRUE) {
[17:29:05.408]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:05.408]                 open = "w")
[17:29:05.408]         }
[17:29:05.408]         else {
[17:29:05.408]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:05.408]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:05.408]         }
[17:29:05.408]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:05.408]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:05.408]             base::sink(type = "output", split = FALSE)
[17:29:05.408]             base::close(...future.stdout)
[17:29:05.408]         }, add = TRUE)
[17:29:05.408]     }
[17:29:05.408]     ...future.frame <- base::sys.nframe()
[17:29:05.408]     ...future.conditions <- base::list()
[17:29:05.408]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:05.408]     if (FALSE) {
[17:29:05.408]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:05.408]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:05.408]     }
[17:29:05.408]     ...future.result <- base::tryCatch({
[17:29:05.408]         base::withCallingHandlers({
[17:29:05.408]             ...future.value <- base::withVisible(base::local({
[17:29:05.408]                 1
[17:29:05.408]             }))
[17:29:05.408]             future::FutureResult(value = ...future.value$value, 
[17:29:05.408]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:05.408]                   ...future.rng), globalenv = if (FALSE) 
[17:29:05.408]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:05.408]                     ...future.globalenv.names))
[17:29:05.408]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:05.408]         }, condition = base::local({
[17:29:05.408]             c <- base::c
[17:29:05.408]             inherits <- base::inherits
[17:29:05.408]             invokeRestart <- base::invokeRestart
[17:29:05.408]             length <- base::length
[17:29:05.408]             list <- base::list
[17:29:05.408]             seq.int <- base::seq.int
[17:29:05.408]             signalCondition <- base::signalCondition
[17:29:05.408]             sys.calls <- base::sys.calls
[17:29:05.408]             `[[` <- base::`[[`
[17:29:05.408]             `+` <- base::`+`
[17:29:05.408]             `<<-` <- base::`<<-`
[17:29:05.408]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:05.408]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:05.408]                   3L)]
[17:29:05.408]             }
[17:29:05.408]             function(cond) {
[17:29:05.408]                 is_error <- inherits(cond, "error")
[17:29:05.408]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:05.408]                   NULL)
[17:29:05.408]                 if (is_error) {
[17:29:05.408]                   sessionInformation <- function() {
[17:29:05.408]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:05.408]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:05.408]                       search = base::search(), system = base::Sys.info())
[17:29:05.408]                   }
[17:29:05.408]                   ...future.conditions[[length(...future.conditions) + 
[17:29:05.408]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:05.408]                     cond$call), session = sessionInformation(), 
[17:29:05.408]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:05.408]                   signalCondition(cond)
[17:29:05.408]                 }
[17:29:05.408]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:05.408]                 "immediateCondition"))) {
[17:29:05.408]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:05.408]                   ...future.conditions[[length(...future.conditions) + 
[17:29:05.408]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:05.408]                   if (TRUE && !signal) {
[17:29:05.408]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:05.408]                     {
[17:29:05.408]                       inherits <- base::inherits
[17:29:05.408]                       invokeRestart <- base::invokeRestart
[17:29:05.408]                       is.null <- base::is.null
[17:29:05.408]                       muffled <- FALSE
[17:29:05.408]                       if (inherits(cond, "message")) {
[17:29:05.408]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:05.408]                         if (muffled) 
[17:29:05.408]                           invokeRestart("muffleMessage")
[17:29:05.408]                       }
[17:29:05.408]                       else if (inherits(cond, "warning")) {
[17:29:05.408]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:05.408]                         if (muffled) 
[17:29:05.408]                           invokeRestart("muffleWarning")
[17:29:05.408]                       }
[17:29:05.408]                       else if (inherits(cond, "condition")) {
[17:29:05.408]                         if (!is.null(pattern)) {
[17:29:05.408]                           computeRestarts <- base::computeRestarts
[17:29:05.408]                           grepl <- base::grepl
[17:29:05.408]                           restarts <- computeRestarts(cond)
[17:29:05.408]                           for (restart in restarts) {
[17:29:05.408]                             name <- restart$name
[17:29:05.408]                             if (is.null(name)) 
[17:29:05.408]                               next
[17:29:05.408]                             if (!grepl(pattern, name)) 
[17:29:05.408]                               next
[17:29:05.408]                             invokeRestart(restart)
[17:29:05.408]                             muffled <- TRUE
[17:29:05.408]                             break
[17:29:05.408]                           }
[17:29:05.408]                         }
[17:29:05.408]                       }
[17:29:05.408]                       invisible(muffled)
[17:29:05.408]                     }
[17:29:05.408]                     muffleCondition(cond, pattern = "^muffle")
[17:29:05.408]                   }
[17:29:05.408]                 }
[17:29:05.408]                 else {
[17:29:05.408]                   if (TRUE) {
[17:29:05.408]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:05.408]                     {
[17:29:05.408]                       inherits <- base::inherits
[17:29:05.408]                       invokeRestart <- base::invokeRestart
[17:29:05.408]                       is.null <- base::is.null
[17:29:05.408]                       muffled <- FALSE
[17:29:05.408]                       if (inherits(cond, "message")) {
[17:29:05.408]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:05.408]                         if (muffled) 
[17:29:05.408]                           invokeRestart("muffleMessage")
[17:29:05.408]                       }
[17:29:05.408]                       else if (inherits(cond, "warning")) {
[17:29:05.408]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:05.408]                         if (muffled) 
[17:29:05.408]                           invokeRestart("muffleWarning")
[17:29:05.408]                       }
[17:29:05.408]                       else if (inherits(cond, "condition")) {
[17:29:05.408]                         if (!is.null(pattern)) {
[17:29:05.408]                           computeRestarts <- base::computeRestarts
[17:29:05.408]                           grepl <- base::grepl
[17:29:05.408]                           restarts <- computeRestarts(cond)
[17:29:05.408]                           for (restart in restarts) {
[17:29:05.408]                             name <- restart$name
[17:29:05.408]                             if (is.null(name)) 
[17:29:05.408]                               next
[17:29:05.408]                             if (!grepl(pattern, name)) 
[17:29:05.408]                               next
[17:29:05.408]                             invokeRestart(restart)
[17:29:05.408]                             muffled <- TRUE
[17:29:05.408]                             break
[17:29:05.408]                           }
[17:29:05.408]                         }
[17:29:05.408]                       }
[17:29:05.408]                       invisible(muffled)
[17:29:05.408]                     }
[17:29:05.408]                     muffleCondition(cond, pattern = "^muffle")
[17:29:05.408]                   }
[17:29:05.408]                 }
[17:29:05.408]             }
[17:29:05.408]         }))
[17:29:05.408]     }, error = function(ex) {
[17:29:05.408]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:05.408]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:05.408]                 ...future.rng), started = ...future.startTime, 
[17:29:05.408]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:05.408]             version = "1.8"), class = "FutureResult")
[17:29:05.408]     }, finally = {
[17:29:05.408]         if (!identical(...future.workdir, getwd())) 
[17:29:05.408]             setwd(...future.workdir)
[17:29:05.408]         {
[17:29:05.408]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:05.408]                 ...future.oldOptions$nwarnings <- NULL
[17:29:05.408]             }
[17:29:05.408]             base::options(...future.oldOptions)
[17:29:05.408]             if (.Platform$OS.type == "windows") {
[17:29:05.408]                 old_names <- names(...future.oldEnvVars)
[17:29:05.408]                 envs <- base::Sys.getenv()
[17:29:05.408]                 names <- names(envs)
[17:29:05.408]                 common <- intersect(names, old_names)
[17:29:05.408]                 added <- setdiff(names, old_names)
[17:29:05.408]                 removed <- setdiff(old_names, names)
[17:29:05.408]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:05.408]                   envs[common]]
[17:29:05.408]                 NAMES <- toupper(changed)
[17:29:05.408]                 args <- list()
[17:29:05.408]                 for (kk in seq_along(NAMES)) {
[17:29:05.408]                   name <- changed[[kk]]
[17:29:05.408]                   NAME <- NAMES[[kk]]
[17:29:05.408]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.408]                     next
[17:29:05.408]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:05.408]                 }
[17:29:05.408]                 NAMES <- toupper(added)
[17:29:05.408]                 for (kk in seq_along(NAMES)) {
[17:29:05.408]                   name <- added[[kk]]
[17:29:05.408]                   NAME <- NAMES[[kk]]
[17:29:05.408]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.408]                     next
[17:29:05.408]                   args[[name]] <- ""
[17:29:05.408]                 }
[17:29:05.408]                 NAMES <- toupper(removed)
[17:29:05.408]                 for (kk in seq_along(NAMES)) {
[17:29:05.408]                   name <- removed[[kk]]
[17:29:05.408]                   NAME <- NAMES[[kk]]
[17:29:05.408]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.408]                     next
[17:29:05.408]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:05.408]                 }
[17:29:05.408]                 if (length(args) > 0) 
[17:29:05.408]                   base::do.call(base::Sys.setenv, args = args)
[17:29:05.408]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:05.408]             }
[17:29:05.408]             else {
[17:29:05.408]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:05.408]             }
[17:29:05.408]             {
[17:29:05.408]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:05.408]                   0L) {
[17:29:05.408]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:05.408]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:05.408]                   base::options(opts)
[17:29:05.408]                 }
[17:29:05.408]                 {
[17:29:05.408]                   {
[17:29:05.408]                     NULL
[17:29:05.408]                     RNGkind("Mersenne-Twister")
[17:29:05.408]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:05.408]                       inherits = FALSE)
[17:29:05.408]                   }
[17:29:05.408]                   options(future.plan = NULL)
[17:29:05.408]                   if (is.na(NA_character_)) 
[17:29:05.408]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:05.408]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:05.408]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:05.408]                     .init = FALSE)
[17:29:05.408]                 }
[17:29:05.408]             }
[17:29:05.408]         }
[17:29:05.408]     })
[17:29:05.408]     if (TRUE) {
[17:29:05.408]         base::sink(type = "output", split = FALSE)
[17:29:05.408]         if (TRUE) {
[17:29:05.408]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:05.408]         }
[17:29:05.408]         else {
[17:29:05.408]             ...future.result["stdout"] <- base::list(NULL)
[17:29:05.408]         }
[17:29:05.408]         base::close(...future.stdout)
[17:29:05.408]         ...future.stdout <- NULL
[17:29:05.408]     }
[17:29:05.408]     ...future.result$conditions <- ...future.conditions
[17:29:05.408]     ...future.result$finished <- base::Sys.time()
[17:29:05.408]     ...future.result
[17:29:05.408] }
[17:29:05.414] plan(): Setting new future strategy stack:
[17:29:05.414] List of future strategies:
[17:29:05.414] 1. sequential:
[17:29:05.414]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:05.414]    - tweaked: FALSE
[17:29:05.414]    - call: NULL
[17:29:05.415] plan(): nbrOfWorkers() = 1
[17:29:05.416] plan(): Setting new future strategy stack:
[17:29:05.416] List of future strategies:
[17:29:05.416] 1. sequential:
[17:29:05.416]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:05.416]    - tweaked: FALSE
[17:29:05.416]    - call: plan(strategy)
[17:29:05.417] plan(): nbrOfWorkers() = 1
[17:29:05.417] SequentialFuture started (and completed)
[17:29:05.417] - Launch lazy future ... done
[17:29:05.418] run() for 'SequentialFuture' ... done
[17:29:05.418] getGlobalsAndPackages() ...
[17:29:05.418] Searching for globals...
[17:29:05.419] - globals found: [1] '{'
[17:29:05.419] Searching for globals ... DONE
[17:29:05.419] Resolving globals: FALSE
[17:29:05.420] 
[17:29:05.420] 
[17:29:05.420] getGlobalsAndPackages() ... DONE
[17:29:05.420] run() for 'Future' ...
[17:29:05.421] - state: 'created'
[17:29:05.421] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:05.421] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:05.421] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:05.422]   - Field: 'label'
[17:29:05.422]   - Field: 'local'
[17:29:05.422]   - Field: 'owner'
[17:29:05.422]   - Field: 'envir'
[17:29:05.422]   - Field: 'packages'
[17:29:05.422]   - Field: 'gc'
[17:29:05.423]   - Field: 'conditions'
[17:29:05.423]   - Field: 'expr'
[17:29:05.423]   - Field: 'uuid'
[17:29:05.423]   - Field: 'seed'
[17:29:05.423]   - Field: 'version'
[17:29:05.424]   - Field: 'result'
[17:29:05.424]   - Field: 'asynchronous'
[17:29:05.424]   - Field: 'calls'
[17:29:05.424]   - Field: 'globals'
[17:29:05.424]   - Field: 'stdout'
[17:29:05.425]   - Field: 'earlySignal'
[17:29:05.425]   - Field: 'lazy'
[17:29:05.425]   - Field: 'state'
[17:29:05.426] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:05.426] - Launch lazy future ...
[17:29:05.426] Packages needed by the future expression (n = 0): <none>
[17:29:05.427] Packages needed by future strategies (n = 0): <none>
[17:29:05.428] {
[17:29:05.428]     {
[17:29:05.428]         {
[17:29:05.428]             ...future.startTime <- base::Sys.time()
[17:29:05.428]             {
[17:29:05.428]                 {
[17:29:05.428]                   {
[17:29:05.428]                     base::local({
[17:29:05.428]                       has_future <- base::requireNamespace("future", 
[17:29:05.428]                         quietly = TRUE)
[17:29:05.428]                       if (has_future) {
[17:29:05.428]                         ns <- base::getNamespace("future")
[17:29:05.428]                         version <- ns[[".package"]][["version"]]
[17:29:05.428]                         if (is.null(version)) 
[17:29:05.428]                           version <- utils::packageVersion("future")
[17:29:05.428]                       }
[17:29:05.428]                       else {
[17:29:05.428]                         version <- NULL
[17:29:05.428]                       }
[17:29:05.428]                       if (!has_future || version < "1.8.0") {
[17:29:05.428]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:05.428]                           "", base::R.version$version.string), 
[17:29:05.428]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:05.428]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:05.428]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:05.428]                             "release", "version")], collapse = " "), 
[17:29:05.428]                           hostname = base::Sys.info()[["nodename"]])
[17:29:05.428]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:05.428]                           info)
[17:29:05.428]                         info <- base::paste(info, collapse = "; ")
[17:29:05.428]                         if (!has_future) {
[17:29:05.428]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:05.428]                             info)
[17:29:05.428]                         }
[17:29:05.428]                         else {
[17:29:05.428]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:05.428]                             info, version)
[17:29:05.428]                         }
[17:29:05.428]                         base::stop(msg)
[17:29:05.428]                       }
[17:29:05.428]                     })
[17:29:05.428]                   }
[17:29:05.428]                   ...future.strategy.old <- future::plan("list")
[17:29:05.428]                   options(future.plan = NULL)
[17:29:05.428]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:05.428]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:05.428]                 }
[17:29:05.428]                 ...future.workdir <- getwd()
[17:29:05.428]             }
[17:29:05.428]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:05.428]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:05.428]         }
[17:29:05.428]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:05.428]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:05.428]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:05.428]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:05.428]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:05.428]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:05.428]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:05.428]             base::names(...future.oldOptions))
[17:29:05.428]     }
[17:29:05.428]     if (FALSE) {
[17:29:05.428]     }
[17:29:05.428]     else {
[17:29:05.428]         if (TRUE) {
[17:29:05.428]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:05.428]                 open = "w")
[17:29:05.428]         }
[17:29:05.428]         else {
[17:29:05.428]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:05.428]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:05.428]         }
[17:29:05.428]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:05.428]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:05.428]             base::sink(type = "output", split = FALSE)
[17:29:05.428]             base::close(...future.stdout)
[17:29:05.428]         }, add = TRUE)
[17:29:05.428]     }
[17:29:05.428]     ...future.frame <- base::sys.nframe()
[17:29:05.428]     ...future.conditions <- base::list()
[17:29:05.428]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:05.428]     if (FALSE) {
[17:29:05.428]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:05.428]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:05.428]     }
[17:29:05.428]     ...future.result <- base::tryCatch({
[17:29:05.428]         base::withCallingHandlers({
[17:29:05.428]             ...future.value <- base::withVisible(base::local({
[17:29:05.428]                 2
[17:29:05.428]             }))
[17:29:05.428]             future::FutureResult(value = ...future.value$value, 
[17:29:05.428]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:05.428]                   ...future.rng), globalenv = if (FALSE) 
[17:29:05.428]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:05.428]                     ...future.globalenv.names))
[17:29:05.428]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:05.428]         }, condition = base::local({
[17:29:05.428]             c <- base::c
[17:29:05.428]             inherits <- base::inherits
[17:29:05.428]             invokeRestart <- base::invokeRestart
[17:29:05.428]             length <- base::length
[17:29:05.428]             list <- base::list
[17:29:05.428]             seq.int <- base::seq.int
[17:29:05.428]             signalCondition <- base::signalCondition
[17:29:05.428]             sys.calls <- base::sys.calls
[17:29:05.428]             `[[` <- base::`[[`
[17:29:05.428]             `+` <- base::`+`
[17:29:05.428]             `<<-` <- base::`<<-`
[17:29:05.428]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:05.428]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:05.428]                   3L)]
[17:29:05.428]             }
[17:29:05.428]             function(cond) {
[17:29:05.428]                 is_error <- inherits(cond, "error")
[17:29:05.428]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:05.428]                   NULL)
[17:29:05.428]                 if (is_error) {
[17:29:05.428]                   sessionInformation <- function() {
[17:29:05.428]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:05.428]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:05.428]                       search = base::search(), system = base::Sys.info())
[17:29:05.428]                   }
[17:29:05.428]                   ...future.conditions[[length(...future.conditions) + 
[17:29:05.428]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:05.428]                     cond$call), session = sessionInformation(), 
[17:29:05.428]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:05.428]                   signalCondition(cond)
[17:29:05.428]                 }
[17:29:05.428]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:05.428]                 "immediateCondition"))) {
[17:29:05.428]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:05.428]                   ...future.conditions[[length(...future.conditions) + 
[17:29:05.428]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:05.428]                   if (TRUE && !signal) {
[17:29:05.428]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:05.428]                     {
[17:29:05.428]                       inherits <- base::inherits
[17:29:05.428]                       invokeRestart <- base::invokeRestart
[17:29:05.428]                       is.null <- base::is.null
[17:29:05.428]                       muffled <- FALSE
[17:29:05.428]                       if (inherits(cond, "message")) {
[17:29:05.428]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:05.428]                         if (muffled) 
[17:29:05.428]                           invokeRestart("muffleMessage")
[17:29:05.428]                       }
[17:29:05.428]                       else if (inherits(cond, "warning")) {
[17:29:05.428]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:05.428]                         if (muffled) 
[17:29:05.428]                           invokeRestart("muffleWarning")
[17:29:05.428]                       }
[17:29:05.428]                       else if (inherits(cond, "condition")) {
[17:29:05.428]                         if (!is.null(pattern)) {
[17:29:05.428]                           computeRestarts <- base::computeRestarts
[17:29:05.428]                           grepl <- base::grepl
[17:29:05.428]                           restarts <- computeRestarts(cond)
[17:29:05.428]                           for (restart in restarts) {
[17:29:05.428]                             name <- restart$name
[17:29:05.428]                             if (is.null(name)) 
[17:29:05.428]                               next
[17:29:05.428]                             if (!grepl(pattern, name)) 
[17:29:05.428]                               next
[17:29:05.428]                             invokeRestart(restart)
[17:29:05.428]                             muffled <- TRUE
[17:29:05.428]                             break
[17:29:05.428]                           }
[17:29:05.428]                         }
[17:29:05.428]                       }
[17:29:05.428]                       invisible(muffled)
[17:29:05.428]                     }
[17:29:05.428]                     muffleCondition(cond, pattern = "^muffle")
[17:29:05.428]                   }
[17:29:05.428]                 }
[17:29:05.428]                 else {
[17:29:05.428]                   if (TRUE) {
[17:29:05.428]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:05.428]                     {
[17:29:05.428]                       inherits <- base::inherits
[17:29:05.428]                       invokeRestart <- base::invokeRestart
[17:29:05.428]                       is.null <- base::is.null
[17:29:05.428]                       muffled <- FALSE
[17:29:05.428]                       if (inherits(cond, "message")) {
[17:29:05.428]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:05.428]                         if (muffled) 
[17:29:05.428]                           invokeRestart("muffleMessage")
[17:29:05.428]                       }
[17:29:05.428]                       else if (inherits(cond, "warning")) {
[17:29:05.428]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:05.428]                         if (muffled) 
[17:29:05.428]                           invokeRestart("muffleWarning")
[17:29:05.428]                       }
[17:29:05.428]                       else if (inherits(cond, "condition")) {
[17:29:05.428]                         if (!is.null(pattern)) {
[17:29:05.428]                           computeRestarts <- base::computeRestarts
[17:29:05.428]                           grepl <- base::grepl
[17:29:05.428]                           restarts <- computeRestarts(cond)
[17:29:05.428]                           for (restart in restarts) {
[17:29:05.428]                             name <- restart$name
[17:29:05.428]                             if (is.null(name)) 
[17:29:05.428]                               next
[17:29:05.428]                             if (!grepl(pattern, name)) 
[17:29:05.428]                               next
[17:29:05.428]                             invokeRestart(restart)
[17:29:05.428]                             muffled <- TRUE
[17:29:05.428]                             break
[17:29:05.428]                           }
[17:29:05.428]                         }
[17:29:05.428]                       }
[17:29:05.428]                       invisible(muffled)
[17:29:05.428]                     }
[17:29:05.428]                     muffleCondition(cond, pattern = "^muffle")
[17:29:05.428]                   }
[17:29:05.428]                 }
[17:29:05.428]             }
[17:29:05.428]         }))
[17:29:05.428]     }, error = function(ex) {
[17:29:05.428]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:05.428]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:05.428]                 ...future.rng), started = ...future.startTime, 
[17:29:05.428]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:05.428]             version = "1.8"), class = "FutureResult")
[17:29:05.428]     }, finally = {
[17:29:05.428]         if (!identical(...future.workdir, getwd())) 
[17:29:05.428]             setwd(...future.workdir)
[17:29:05.428]         {
[17:29:05.428]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:05.428]                 ...future.oldOptions$nwarnings <- NULL
[17:29:05.428]             }
[17:29:05.428]             base::options(...future.oldOptions)
[17:29:05.428]             if (.Platform$OS.type == "windows") {
[17:29:05.428]                 old_names <- names(...future.oldEnvVars)
[17:29:05.428]                 envs <- base::Sys.getenv()
[17:29:05.428]                 names <- names(envs)
[17:29:05.428]                 common <- intersect(names, old_names)
[17:29:05.428]                 added <- setdiff(names, old_names)
[17:29:05.428]                 removed <- setdiff(old_names, names)
[17:29:05.428]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:05.428]                   envs[common]]
[17:29:05.428]                 NAMES <- toupper(changed)
[17:29:05.428]                 args <- list()
[17:29:05.428]                 for (kk in seq_along(NAMES)) {
[17:29:05.428]                   name <- changed[[kk]]
[17:29:05.428]                   NAME <- NAMES[[kk]]
[17:29:05.428]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.428]                     next
[17:29:05.428]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:05.428]                 }
[17:29:05.428]                 NAMES <- toupper(added)
[17:29:05.428]                 for (kk in seq_along(NAMES)) {
[17:29:05.428]                   name <- added[[kk]]
[17:29:05.428]                   NAME <- NAMES[[kk]]
[17:29:05.428]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.428]                     next
[17:29:05.428]                   args[[name]] <- ""
[17:29:05.428]                 }
[17:29:05.428]                 NAMES <- toupper(removed)
[17:29:05.428]                 for (kk in seq_along(NAMES)) {
[17:29:05.428]                   name <- removed[[kk]]
[17:29:05.428]                   NAME <- NAMES[[kk]]
[17:29:05.428]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.428]                     next
[17:29:05.428]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:05.428]                 }
[17:29:05.428]                 if (length(args) > 0) 
[17:29:05.428]                   base::do.call(base::Sys.setenv, args = args)
[17:29:05.428]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:05.428]             }
[17:29:05.428]             else {
[17:29:05.428]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:05.428]             }
[17:29:05.428]             {
[17:29:05.428]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:05.428]                   0L) {
[17:29:05.428]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:05.428]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:05.428]                   base::options(opts)
[17:29:05.428]                 }
[17:29:05.428]                 {
[17:29:05.428]                   {
[17:29:05.428]                     NULL
[17:29:05.428]                     RNGkind("Mersenne-Twister")
[17:29:05.428]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:05.428]                       inherits = FALSE)
[17:29:05.428]                   }
[17:29:05.428]                   options(future.plan = NULL)
[17:29:05.428]                   if (is.na(NA_character_)) 
[17:29:05.428]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:05.428]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:05.428]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:05.428]                     .init = FALSE)
[17:29:05.428]                 }
[17:29:05.428]             }
[17:29:05.428]         }
[17:29:05.428]     })
[17:29:05.428]     if (TRUE) {
[17:29:05.428]         base::sink(type = "output", split = FALSE)
[17:29:05.428]         if (TRUE) {
[17:29:05.428]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:05.428]         }
[17:29:05.428]         else {
[17:29:05.428]             ...future.result["stdout"] <- base::list(NULL)
[17:29:05.428]         }
[17:29:05.428]         base::close(...future.stdout)
[17:29:05.428]         ...future.stdout <- NULL
[17:29:05.428]     }
[17:29:05.428]     ...future.result$conditions <- ...future.conditions
[17:29:05.428]     ...future.result$finished <- base::Sys.time()
[17:29:05.428]     ...future.result
[17:29:05.428] }
[17:29:05.435] plan(): Setting new future strategy stack:
[17:29:05.435] List of future strategies:
[17:29:05.435] 1. sequential:
[17:29:05.435]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:05.435]    - tweaked: FALSE
[17:29:05.435]    - call: NULL
[17:29:05.436] plan(): nbrOfWorkers() = 1
[17:29:05.438] plan(): Setting new future strategy stack:
[17:29:05.438] List of future strategies:
[17:29:05.438] 1. sequential:
[17:29:05.438]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:05.438]    - tweaked: FALSE
[17:29:05.438]    - call: plan(strategy)
[17:29:05.439] plan(): nbrOfWorkers() = 1
[17:29:05.440] SequentialFuture started (and completed)
[17:29:05.440] - Launch lazy future ... done
[17:29:05.440] run() for 'SequentialFuture' ... done
[17:29:05.442] resolve() on environment ...
[17:29:05.442]  recursive: 0
[17:29:05.443]  elements: [3] '.future_a', '.future_b', 'a', 'b', 'c'
[17:29:05.443] resolved() for 'SequentialFuture' ...
[17:29:05.444] - state: 'finished'
[17:29:05.444] - run: TRUE
[17:29:05.444] - result: 'FutureResult'
[17:29:05.445] resolved() for 'SequentialFuture' ... done
[17:29:05.445] Future #1
[17:29:05.445]  length: 2 (resolved future 1)
[17:29:05.446] resolved() for 'SequentialFuture' ...
[17:29:05.446] - state: 'finished'
[17:29:05.446] - run: TRUE
[17:29:05.447] - result: 'FutureResult'
[17:29:05.447] resolved() for 'SequentialFuture' ... done
[17:29:05.447] Future #2
[17:29:05.448]  length: 1 (resolved future 2)
[17:29:05.448]  length: 0 (resolved future 3)
[17:29:05.448] resolve() on environment ... DONE
[17:29:05.449] getGlobalsAndPackages() ...
[17:29:05.450] Searching for globals...
[17:29:05.451] - globals found: [1] '{'
[17:29:05.451] Searching for globals ... DONE
[17:29:05.452] Resolving globals: FALSE
[17:29:05.452] 
[17:29:05.453] 
[17:29:05.453] getGlobalsAndPackages() ... DONE
[17:29:05.453] run() for 'Future' ...
[17:29:05.454] - state: 'created'
[17:29:05.454] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:05.455] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:05.455] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:05.456]   - Field: 'label'
[17:29:05.456]   - Field: 'local'
[17:29:05.456]   - Field: 'owner'
[17:29:05.457]   - Field: 'envir'
[17:29:05.457]   - Field: 'packages'
[17:29:05.457]   - Field: 'gc'
[17:29:05.457]   - Field: 'conditions'
[17:29:05.458]   - Field: 'expr'
[17:29:05.458]   - Field: 'uuid'
[17:29:05.458]   - Field: 'seed'
[17:29:05.458]   - Field: 'version'
[17:29:05.458]   - Field: 'result'
[17:29:05.491]   - Field: 'asynchronous'
[17:29:05.492]   - Field: 'calls'
[17:29:05.492]   - Field: 'globals'
[17:29:05.492]   - Field: 'stdout'
[17:29:05.492]   - Field: 'earlySignal'
[17:29:05.493]   - Field: 'lazy'
[17:29:05.493]   - Field: 'state'
[17:29:05.493] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:05.493] - Launch lazy future ...
[17:29:05.494] Packages needed by the future expression (n = 0): <none>
[17:29:05.494] Packages needed by future strategies (n = 0): <none>
[17:29:05.494] {
[17:29:05.494]     {
[17:29:05.494]         {
[17:29:05.494]             ...future.startTime <- base::Sys.time()
[17:29:05.494]             {
[17:29:05.494]                 {
[17:29:05.494]                   {
[17:29:05.494]                     base::local({
[17:29:05.494]                       has_future <- base::requireNamespace("future", 
[17:29:05.494]                         quietly = TRUE)
[17:29:05.494]                       if (has_future) {
[17:29:05.494]                         ns <- base::getNamespace("future")
[17:29:05.494]                         version <- ns[[".package"]][["version"]]
[17:29:05.494]                         if (is.null(version)) 
[17:29:05.494]                           version <- utils::packageVersion("future")
[17:29:05.494]                       }
[17:29:05.494]                       else {
[17:29:05.494]                         version <- NULL
[17:29:05.494]                       }
[17:29:05.494]                       if (!has_future || version < "1.8.0") {
[17:29:05.494]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:05.494]                           "", base::R.version$version.string), 
[17:29:05.494]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:05.494]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:05.494]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:05.494]                             "release", "version")], collapse = " "), 
[17:29:05.494]                           hostname = base::Sys.info()[["nodename"]])
[17:29:05.494]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:05.494]                           info)
[17:29:05.494]                         info <- base::paste(info, collapse = "; ")
[17:29:05.494]                         if (!has_future) {
[17:29:05.494]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:05.494]                             info)
[17:29:05.494]                         }
[17:29:05.494]                         else {
[17:29:05.494]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:05.494]                             info, version)
[17:29:05.494]                         }
[17:29:05.494]                         base::stop(msg)
[17:29:05.494]                       }
[17:29:05.494]                     })
[17:29:05.494]                   }
[17:29:05.494]                   ...future.strategy.old <- future::plan("list")
[17:29:05.494]                   options(future.plan = NULL)
[17:29:05.494]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:05.494]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:05.494]                 }
[17:29:05.494]                 ...future.workdir <- getwd()
[17:29:05.494]             }
[17:29:05.494]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:05.494]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:05.494]         }
[17:29:05.494]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:05.494]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:05.494]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:05.494]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:05.494]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:05.494]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:05.494]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:05.494]             base::names(...future.oldOptions))
[17:29:05.494]     }
[17:29:05.494]     if (FALSE) {
[17:29:05.494]     }
[17:29:05.494]     else {
[17:29:05.494]         if (TRUE) {
[17:29:05.494]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:05.494]                 open = "w")
[17:29:05.494]         }
[17:29:05.494]         else {
[17:29:05.494]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:05.494]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:05.494]         }
[17:29:05.494]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:05.494]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:05.494]             base::sink(type = "output", split = FALSE)
[17:29:05.494]             base::close(...future.stdout)
[17:29:05.494]         }, add = TRUE)
[17:29:05.494]     }
[17:29:05.494]     ...future.frame <- base::sys.nframe()
[17:29:05.494]     ...future.conditions <- base::list()
[17:29:05.494]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:05.494]     if (FALSE) {
[17:29:05.494]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:05.494]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:05.494]     }
[17:29:05.494]     ...future.result <- base::tryCatch({
[17:29:05.494]         base::withCallingHandlers({
[17:29:05.494]             ...future.value <- base::withVisible(base::local({
[17:29:05.494]                 1
[17:29:05.494]             }))
[17:29:05.494]             future::FutureResult(value = ...future.value$value, 
[17:29:05.494]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:05.494]                   ...future.rng), globalenv = if (FALSE) 
[17:29:05.494]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:05.494]                     ...future.globalenv.names))
[17:29:05.494]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:05.494]         }, condition = base::local({
[17:29:05.494]             c <- base::c
[17:29:05.494]             inherits <- base::inherits
[17:29:05.494]             invokeRestart <- base::invokeRestart
[17:29:05.494]             length <- base::length
[17:29:05.494]             list <- base::list
[17:29:05.494]             seq.int <- base::seq.int
[17:29:05.494]             signalCondition <- base::signalCondition
[17:29:05.494]             sys.calls <- base::sys.calls
[17:29:05.494]             `[[` <- base::`[[`
[17:29:05.494]             `+` <- base::`+`
[17:29:05.494]             `<<-` <- base::`<<-`
[17:29:05.494]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:05.494]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:05.494]                   3L)]
[17:29:05.494]             }
[17:29:05.494]             function(cond) {
[17:29:05.494]                 is_error <- inherits(cond, "error")
[17:29:05.494]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:05.494]                   NULL)
[17:29:05.494]                 if (is_error) {
[17:29:05.494]                   sessionInformation <- function() {
[17:29:05.494]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:05.494]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:05.494]                       search = base::search(), system = base::Sys.info())
[17:29:05.494]                   }
[17:29:05.494]                   ...future.conditions[[length(...future.conditions) + 
[17:29:05.494]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:05.494]                     cond$call), session = sessionInformation(), 
[17:29:05.494]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:05.494]                   signalCondition(cond)
[17:29:05.494]                 }
[17:29:05.494]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:05.494]                 "immediateCondition"))) {
[17:29:05.494]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:05.494]                   ...future.conditions[[length(...future.conditions) + 
[17:29:05.494]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:05.494]                   if (TRUE && !signal) {
[17:29:05.494]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:05.494]                     {
[17:29:05.494]                       inherits <- base::inherits
[17:29:05.494]                       invokeRestart <- base::invokeRestart
[17:29:05.494]                       is.null <- base::is.null
[17:29:05.494]                       muffled <- FALSE
[17:29:05.494]                       if (inherits(cond, "message")) {
[17:29:05.494]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:05.494]                         if (muffled) 
[17:29:05.494]                           invokeRestart("muffleMessage")
[17:29:05.494]                       }
[17:29:05.494]                       else if (inherits(cond, "warning")) {
[17:29:05.494]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:05.494]                         if (muffled) 
[17:29:05.494]                           invokeRestart("muffleWarning")
[17:29:05.494]                       }
[17:29:05.494]                       else if (inherits(cond, "condition")) {
[17:29:05.494]                         if (!is.null(pattern)) {
[17:29:05.494]                           computeRestarts <- base::computeRestarts
[17:29:05.494]                           grepl <- base::grepl
[17:29:05.494]                           restarts <- computeRestarts(cond)
[17:29:05.494]                           for (restart in restarts) {
[17:29:05.494]                             name <- restart$name
[17:29:05.494]                             if (is.null(name)) 
[17:29:05.494]                               next
[17:29:05.494]                             if (!grepl(pattern, name)) 
[17:29:05.494]                               next
[17:29:05.494]                             invokeRestart(restart)
[17:29:05.494]                             muffled <- TRUE
[17:29:05.494]                             break
[17:29:05.494]                           }
[17:29:05.494]                         }
[17:29:05.494]                       }
[17:29:05.494]                       invisible(muffled)
[17:29:05.494]                     }
[17:29:05.494]                     muffleCondition(cond, pattern = "^muffle")
[17:29:05.494]                   }
[17:29:05.494]                 }
[17:29:05.494]                 else {
[17:29:05.494]                   if (TRUE) {
[17:29:05.494]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:05.494]                     {
[17:29:05.494]                       inherits <- base::inherits
[17:29:05.494]                       invokeRestart <- base::invokeRestart
[17:29:05.494]                       is.null <- base::is.null
[17:29:05.494]                       muffled <- FALSE
[17:29:05.494]                       if (inherits(cond, "message")) {
[17:29:05.494]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:05.494]                         if (muffled) 
[17:29:05.494]                           invokeRestart("muffleMessage")
[17:29:05.494]                       }
[17:29:05.494]                       else if (inherits(cond, "warning")) {
[17:29:05.494]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:05.494]                         if (muffled) 
[17:29:05.494]                           invokeRestart("muffleWarning")
[17:29:05.494]                       }
[17:29:05.494]                       else if (inherits(cond, "condition")) {
[17:29:05.494]                         if (!is.null(pattern)) {
[17:29:05.494]                           computeRestarts <- base::computeRestarts
[17:29:05.494]                           grepl <- base::grepl
[17:29:05.494]                           restarts <- computeRestarts(cond)
[17:29:05.494]                           for (restart in restarts) {
[17:29:05.494]                             name <- restart$name
[17:29:05.494]                             if (is.null(name)) 
[17:29:05.494]                               next
[17:29:05.494]                             if (!grepl(pattern, name)) 
[17:29:05.494]                               next
[17:29:05.494]                             invokeRestart(restart)
[17:29:05.494]                             muffled <- TRUE
[17:29:05.494]                             break
[17:29:05.494]                           }
[17:29:05.494]                         }
[17:29:05.494]                       }
[17:29:05.494]                       invisible(muffled)
[17:29:05.494]                     }
[17:29:05.494]                     muffleCondition(cond, pattern = "^muffle")
[17:29:05.494]                   }
[17:29:05.494]                 }
[17:29:05.494]             }
[17:29:05.494]         }))
[17:29:05.494]     }, error = function(ex) {
[17:29:05.494]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:05.494]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:05.494]                 ...future.rng), started = ...future.startTime, 
[17:29:05.494]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:05.494]             version = "1.8"), class = "FutureResult")
[17:29:05.494]     }, finally = {
[17:29:05.494]         if (!identical(...future.workdir, getwd())) 
[17:29:05.494]             setwd(...future.workdir)
[17:29:05.494]         {
[17:29:05.494]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:05.494]                 ...future.oldOptions$nwarnings <- NULL
[17:29:05.494]             }
[17:29:05.494]             base::options(...future.oldOptions)
[17:29:05.494]             if (.Platform$OS.type == "windows") {
[17:29:05.494]                 old_names <- names(...future.oldEnvVars)
[17:29:05.494]                 envs <- base::Sys.getenv()
[17:29:05.494]                 names <- names(envs)
[17:29:05.494]                 common <- intersect(names, old_names)
[17:29:05.494]                 added <- setdiff(names, old_names)
[17:29:05.494]                 removed <- setdiff(old_names, names)
[17:29:05.494]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:05.494]                   envs[common]]
[17:29:05.494]                 NAMES <- toupper(changed)
[17:29:05.494]                 args <- list()
[17:29:05.494]                 for (kk in seq_along(NAMES)) {
[17:29:05.494]                   name <- changed[[kk]]
[17:29:05.494]                   NAME <- NAMES[[kk]]
[17:29:05.494]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.494]                     next
[17:29:05.494]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:05.494]                 }
[17:29:05.494]                 NAMES <- toupper(added)
[17:29:05.494]                 for (kk in seq_along(NAMES)) {
[17:29:05.494]                   name <- added[[kk]]
[17:29:05.494]                   NAME <- NAMES[[kk]]
[17:29:05.494]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.494]                     next
[17:29:05.494]                   args[[name]] <- ""
[17:29:05.494]                 }
[17:29:05.494]                 NAMES <- toupper(removed)
[17:29:05.494]                 for (kk in seq_along(NAMES)) {
[17:29:05.494]                   name <- removed[[kk]]
[17:29:05.494]                   NAME <- NAMES[[kk]]
[17:29:05.494]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.494]                     next
[17:29:05.494]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:05.494]                 }
[17:29:05.494]                 if (length(args) > 0) 
[17:29:05.494]                   base::do.call(base::Sys.setenv, args = args)
[17:29:05.494]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:05.494]             }
[17:29:05.494]             else {
[17:29:05.494]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:05.494]             }
[17:29:05.494]             {
[17:29:05.494]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:05.494]                   0L) {
[17:29:05.494]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:05.494]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:05.494]                   base::options(opts)
[17:29:05.494]                 }
[17:29:05.494]                 {
[17:29:05.494]                   {
[17:29:05.494]                     NULL
[17:29:05.494]                     RNGkind("Mersenne-Twister")
[17:29:05.494]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:05.494]                       inherits = FALSE)
[17:29:05.494]                   }
[17:29:05.494]                   options(future.plan = NULL)
[17:29:05.494]                   if (is.na(NA_character_)) 
[17:29:05.494]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:05.494]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:05.494]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:05.494]                     .init = FALSE)
[17:29:05.494]                 }
[17:29:05.494]             }
[17:29:05.494]         }
[17:29:05.494]     })
[17:29:05.494]     if (TRUE) {
[17:29:05.494]         base::sink(type = "output", split = FALSE)
[17:29:05.494]         if (TRUE) {
[17:29:05.494]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:05.494]         }
[17:29:05.494]         else {
[17:29:05.494]             ...future.result["stdout"] <- base::list(NULL)
[17:29:05.494]         }
[17:29:05.494]         base::close(...future.stdout)
[17:29:05.494]         ...future.stdout <- NULL
[17:29:05.494]     }
[17:29:05.494]     ...future.result$conditions <- ...future.conditions
[17:29:05.494]     ...future.result$finished <- base::Sys.time()
[17:29:05.494]     ...future.result
[17:29:05.494] }
[17:29:05.499] plan(): Setting new future strategy stack:
[17:29:05.499] List of future strategies:
[17:29:05.499] 1. sequential:
[17:29:05.499]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:05.499]    - tweaked: FALSE
[17:29:05.499]    - call: NULL
[17:29:05.499] plan(): nbrOfWorkers() = 1
[17:29:05.501] plan(): Setting new future strategy stack:
[17:29:05.501] List of future strategies:
[17:29:05.501] 1. sequential:
[17:29:05.501]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:05.501]    - tweaked: FALSE
[17:29:05.501]    - call: plan(strategy)
[17:29:05.502] plan(): nbrOfWorkers() = 1
[17:29:05.502] SequentialFuture started (and completed)
[17:29:05.502] - Launch lazy future ... done
[17:29:05.502] run() for 'SequentialFuture' ... done
[17:29:05.503] getGlobalsAndPackages() ...
[17:29:05.503] Searching for globals...
[17:29:05.504] - globals found: [1] '{'
[17:29:05.504] Searching for globals ... DONE
[17:29:05.504] Resolving globals: FALSE
[17:29:05.505] 
[17:29:05.505] 
[17:29:05.505] getGlobalsAndPackages() ... DONE
[17:29:05.505] run() for 'Future' ...
[17:29:05.506] - state: 'created'
[17:29:05.506] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:05.506] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:05.506] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:05.507]   - Field: 'label'
[17:29:05.507]   - Field: 'local'
[17:29:05.507]   - Field: 'owner'
[17:29:05.507]   - Field: 'envir'
[17:29:05.507]   - Field: 'packages'
[17:29:05.507]   - Field: 'gc'
[17:29:05.508]   - Field: 'conditions'
[17:29:05.508]   - Field: 'expr'
[17:29:05.508]   - Field: 'uuid'
[17:29:05.508]   - Field: 'seed'
[17:29:05.508]   - Field: 'version'
[17:29:05.509]   - Field: 'result'
[17:29:05.509]   - Field: 'asynchronous'
[17:29:05.509]   - Field: 'calls'
[17:29:05.509]   - Field: 'globals'
[17:29:05.509]   - Field: 'stdout'
[17:29:05.509]   - Field: 'earlySignal'
[17:29:05.510]   - Field: 'lazy'
[17:29:05.510]   - Field: 'state'
[17:29:05.510] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:05.510] - Launch lazy future ...
[17:29:05.510] Packages needed by the future expression (n = 0): <none>
[17:29:05.511] Packages needed by future strategies (n = 0): <none>
[17:29:05.511] {
[17:29:05.511]     {
[17:29:05.511]         {
[17:29:05.511]             ...future.startTime <- base::Sys.time()
[17:29:05.511]             {
[17:29:05.511]                 {
[17:29:05.511]                   {
[17:29:05.511]                     base::local({
[17:29:05.511]                       has_future <- base::requireNamespace("future", 
[17:29:05.511]                         quietly = TRUE)
[17:29:05.511]                       if (has_future) {
[17:29:05.511]                         ns <- base::getNamespace("future")
[17:29:05.511]                         version <- ns[[".package"]][["version"]]
[17:29:05.511]                         if (is.null(version)) 
[17:29:05.511]                           version <- utils::packageVersion("future")
[17:29:05.511]                       }
[17:29:05.511]                       else {
[17:29:05.511]                         version <- NULL
[17:29:05.511]                       }
[17:29:05.511]                       if (!has_future || version < "1.8.0") {
[17:29:05.511]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:05.511]                           "", base::R.version$version.string), 
[17:29:05.511]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:05.511]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:05.511]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:05.511]                             "release", "version")], collapse = " "), 
[17:29:05.511]                           hostname = base::Sys.info()[["nodename"]])
[17:29:05.511]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:05.511]                           info)
[17:29:05.511]                         info <- base::paste(info, collapse = "; ")
[17:29:05.511]                         if (!has_future) {
[17:29:05.511]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:05.511]                             info)
[17:29:05.511]                         }
[17:29:05.511]                         else {
[17:29:05.511]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:05.511]                             info, version)
[17:29:05.511]                         }
[17:29:05.511]                         base::stop(msg)
[17:29:05.511]                       }
[17:29:05.511]                     })
[17:29:05.511]                   }
[17:29:05.511]                   ...future.strategy.old <- future::plan("list")
[17:29:05.511]                   options(future.plan = NULL)
[17:29:05.511]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:05.511]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:05.511]                 }
[17:29:05.511]                 ...future.workdir <- getwd()
[17:29:05.511]             }
[17:29:05.511]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:05.511]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:05.511]         }
[17:29:05.511]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:05.511]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:05.511]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:05.511]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:05.511]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:05.511]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:05.511]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:05.511]             base::names(...future.oldOptions))
[17:29:05.511]     }
[17:29:05.511]     if (FALSE) {
[17:29:05.511]     }
[17:29:05.511]     else {
[17:29:05.511]         if (TRUE) {
[17:29:05.511]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:05.511]                 open = "w")
[17:29:05.511]         }
[17:29:05.511]         else {
[17:29:05.511]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:05.511]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:05.511]         }
[17:29:05.511]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:05.511]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:05.511]             base::sink(type = "output", split = FALSE)
[17:29:05.511]             base::close(...future.stdout)
[17:29:05.511]         }, add = TRUE)
[17:29:05.511]     }
[17:29:05.511]     ...future.frame <- base::sys.nframe()
[17:29:05.511]     ...future.conditions <- base::list()
[17:29:05.511]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:05.511]     if (FALSE) {
[17:29:05.511]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:05.511]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:05.511]     }
[17:29:05.511]     ...future.result <- base::tryCatch({
[17:29:05.511]         base::withCallingHandlers({
[17:29:05.511]             ...future.value <- base::withVisible(base::local({
[17:29:05.511]                 2
[17:29:05.511]             }))
[17:29:05.511]             future::FutureResult(value = ...future.value$value, 
[17:29:05.511]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:05.511]                   ...future.rng), globalenv = if (FALSE) 
[17:29:05.511]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:05.511]                     ...future.globalenv.names))
[17:29:05.511]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:05.511]         }, condition = base::local({
[17:29:05.511]             c <- base::c
[17:29:05.511]             inherits <- base::inherits
[17:29:05.511]             invokeRestart <- base::invokeRestart
[17:29:05.511]             length <- base::length
[17:29:05.511]             list <- base::list
[17:29:05.511]             seq.int <- base::seq.int
[17:29:05.511]             signalCondition <- base::signalCondition
[17:29:05.511]             sys.calls <- base::sys.calls
[17:29:05.511]             `[[` <- base::`[[`
[17:29:05.511]             `+` <- base::`+`
[17:29:05.511]             `<<-` <- base::`<<-`
[17:29:05.511]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:05.511]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:05.511]                   3L)]
[17:29:05.511]             }
[17:29:05.511]             function(cond) {
[17:29:05.511]                 is_error <- inherits(cond, "error")
[17:29:05.511]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:05.511]                   NULL)
[17:29:05.511]                 if (is_error) {
[17:29:05.511]                   sessionInformation <- function() {
[17:29:05.511]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:05.511]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:05.511]                       search = base::search(), system = base::Sys.info())
[17:29:05.511]                   }
[17:29:05.511]                   ...future.conditions[[length(...future.conditions) + 
[17:29:05.511]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:05.511]                     cond$call), session = sessionInformation(), 
[17:29:05.511]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:05.511]                   signalCondition(cond)
[17:29:05.511]                 }
[17:29:05.511]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:05.511]                 "immediateCondition"))) {
[17:29:05.511]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:05.511]                   ...future.conditions[[length(...future.conditions) + 
[17:29:05.511]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:05.511]                   if (TRUE && !signal) {
[17:29:05.511]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:05.511]                     {
[17:29:05.511]                       inherits <- base::inherits
[17:29:05.511]                       invokeRestart <- base::invokeRestart
[17:29:05.511]                       is.null <- base::is.null
[17:29:05.511]                       muffled <- FALSE
[17:29:05.511]                       if (inherits(cond, "message")) {
[17:29:05.511]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:05.511]                         if (muffled) 
[17:29:05.511]                           invokeRestart("muffleMessage")
[17:29:05.511]                       }
[17:29:05.511]                       else if (inherits(cond, "warning")) {
[17:29:05.511]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:05.511]                         if (muffled) 
[17:29:05.511]                           invokeRestart("muffleWarning")
[17:29:05.511]                       }
[17:29:05.511]                       else if (inherits(cond, "condition")) {
[17:29:05.511]                         if (!is.null(pattern)) {
[17:29:05.511]                           computeRestarts <- base::computeRestarts
[17:29:05.511]                           grepl <- base::grepl
[17:29:05.511]                           restarts <- computeRestarts(cond)
[17:29:05.511]                           for (restart in restarts) {
[17:29:05.511]                             name <- restart$name
[17:29:05.511]                             if (is.null(name)) 
[17:29:05.511]                               next
[17:29:05.511]                             if (!grepl(pattern, name)) 
[17:29:05.511]                               next
[17:29:05.511]                             invokeRestart(restart)
[17:29:05.511]                             muffled <- TRUE
[17:29:05.511]                             break
[17:29:05.511]                           }
[17:29:05.511]                         }
[17:29:05.511]                       }
[17:29:05.511]                       invisible(muffled)
[17:29:05.511]                     }
[17:29:05.511]                     muffleCondition(cond, pattern = "^muffle")
[17:29:05.511]                   }
[17:29:05.511]                 }
[17:29:05.511]                 else {
[17:29:05.511]                   if (TRUE) {
[17:29:05.511]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:05.511]                     {
[17:29:05.511]                       inherits <- base::inherits
[17:29:05.511]                       invokeRestart <- base::invokeRestart
[17:29:05.511]                       is.null <- base::is.null
[17:29:05.511]                       muffled <- FALSE
[17:29:05.511]                       if (inherits(cond, "message")) {
[17:29:05.511]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:05.511]                         if (muffled) 
[17:29:05.511]                           invokeRestart("muffleMessage")
[17:29:05.511]                       }
[17:29:05.511]                       else if (inherits(cond, "warning")) {
[17:29:05.511]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:05.511]                         if (muffled) 
[17:29:05.511]                           invokeRestart("muffleWarning")
[17:29:05.511]                       }
[17:29:05.511]                       else if (inherits(cond, "condition")) {
[17:29:05.511]                         if (!is.null(pattern)) {
[17:29:05.511]                           computeRestarts <- base::computeRestarts
[17:29:05.511]                           grepl <- base::grepl
[17:29:05.511]                           restarts <- computeRestarts(cond)
[17:29:05.511]                           for (restart in restarts) {
[17:29:05.511]                             name <- restart$name
[17:29:05.511]                             if (is.null(name)) 
[17:29:05.511]                               next
[17:29:05.511]                             if (!grepl(pattern, name)) 
[17:29:05.511]                               next
[17:29:05.511]                             invokeRestart(restart)
[17:29:05.511]                             muffled <- TRUE
[17:29:05.511]                             break
[17:29:05.511]                           }
[17:29:05.511]                         }
[17:29:05.511]                       }
[17:29:05.511]                       invisible(muffled)
[17:29:05.511]                     }
[17:29:05.511]                     muffleCondition(cond, pattern = "^muffle")
[17:29:05.511]                   }
[17:29:05.511]                 }
[17:29:05.511]             }
[17:29:05.511]         }))
[17:29:05.511]     }, error = function(ex) {
[17:29:05.511]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:05.511]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:05.511]                 ...future.rng), started = ...future.startTime, 
[17:29:05.511]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:05.511]             version = "1.8"), class = "FutureResult")
[17:29:05.511]     }, finally = {
[17:29:05.511]         if (!identical(...future.workdir, getwd())) 
[17:29:05.511]             setwd(...future.workdir)
[17:29:05.511]         {
[17:29:05.511]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:05.511]                 ...future.oldOptions$nwarnings <- NULL
[17:29:05.511]             }
[17:29:05.511]             base::options(...future.oldOptions)
[17:29:05.511]             if (.Platform$OS.type == "windows") {
[17:29:05.511]                 old_names <- names(...future.oldEnvVars)
[17:29:05.511]                 envs <- base::Sys.getenv()
[17:29:05.511]                 names <- names(envs)
[17:29:05.511]                 common <- intersect(names, old_names)
[17:29:05.511]                 added <- setdiff(names, old_names)
[17:29:05.511]                 removed <- setdiff(old_names, names)
[17:29:05.511]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:05.511]                   envs[common]]
[17:29:05.511]                 NAMES <- toupper(changed)
[17:29:05.511]                 args <- list()
[17:29:05.511]                 for (kk in seq_along(NAMES)) {
[17:29:05.511]                   name <- changed[[kk]]
[17:29:05.511]                   NAME <- NAMES[[kk]]
[17:29:05.511]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.511]                     next
[17:29:05.511]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:05.511]                 }
[17:29:05.511]                 NAMES <- toupper(added)
[17:29:05.511]                 for (kk in seq_along(NAMES)) {
[17:29:05.511]                   name <- added[[kk]]
[17:29:05.511]                   NAME <- NAMES[[kk]]
[17:29:05.511]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.511]                     next
[17:29:05.511]                   args[[name]] <- ""
[17:29:05.511]                 }
[17:29:05.511]                 NAMES <- toupper(removed)
[17:29:05.511]                 for (kk in seq_along(NAMES)) {
[17:29:05.511]                   name <- removed[[kk]]
[17:29:05.511]                   NAME <- NAMES[[kk]]
[17:29:05.511]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.511]                     next
[17:29:05.511]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:05.511]                 }
[17:29:05.511]                 if (length(args) > 0) 
[17:29:05.511]                   base::do.call(base::Sys.setenv, args = args)
[17:29:05.511]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:05.511]             }
[17:29:05.511]             else {
[17:29:05.511]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:05.511]             }
[17:29:05.511]             {
[17:29:05.511]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:05.511]                   0L) {
[17:29:05.511]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:05.511]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:05.511]                   base::options(opts)
[17:29:05.511]                 }
[17:29:05.511]                 {
[17:29:05.511]                   {
[17:29:05.511]                     NULL
[17:29:05.511]                     RNGkind("Mersenne-Twister")
[17:29:05.511]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:05.511]                       inherits = FALSE)
[17:29:05.511]                   }
[17:29:05.511]                   options(future.plan = NULL)
[17:29:05.511]                   if (is.na(NA_character_)) 
[17:29:05.511]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:05.511]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:05.511]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:05.511]                     .init = FALSE)
[17:29:05.511]                 }
[17:29:05.511]             }
[17:29:05.511]         }
[17:29:05.511]     })
[17:29:05.511]     if (TRUE) {
[17:29:05.511]         base::sink(type = "output", split = FALSE)
[17:29:05.511]         if (TRUE) {
[17:29:05.511]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:05.511]         }
[17:29:05.511]         else {
[17:29:05.511]             ...future.result["stdout"] <- base::list(NULL)
[17:29:05.511]         }
[17:29:05.511]         base::close(...future.stdout)
[17:29:05.511]         ...future.stdout <- NULL
[17:29:05.511]     }
[17:29:05.511]     ...future.result$conditions <- ...future.conditions
[17:29:05.511]     ...future.result$finished <- base::Sys.time()
[17:29:05.511]     ...future.result
[17:29:05.511] }
[17:29:05.515] plan(): Setting new future strategy stack:
[17:29:05.516] List of future strategies:
[17:29:05.516] 1. sequential:
[17:29:05.516]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:05.516]    - tweaked: FALSE
[17:29:05.516]    - call: NULL
[17:29:05.516] plan(): nbrOfWorkers() = 1
[17:29:05.518] plan(): Setting new future strategy stack:
[17:29:05.518] List of future strategies:
[17:29:05.518] 1. sequential:
[17:29:05.518]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:05.518]    - tweaked: FALSE
[17:29:05.518]    - call: plan(strategy)
[17:29:05.519] plan(): nbrOfWorkers() = 1
[17:29:05.519] SequentialFuture started (and completed)
[17:29:05.519] - Launch lazy future ... done
[17:29:05.519] run() for 'SequentialFuture' ... done
[17:29:05.520] resolve() on environment ...
[17:29:05.520]  recursive: 0
[17:29:05.521]  elements: [3] 'a'
[17:29:05.521] resolved() for 'SequentialFuture' ...
[17:29:05.521] - state: 'finished'
[17:29:05.521] - run: TRUE
[17:29:05.522] - result: 'FutureResult'
[17:29:05.522] resolved() for 'SequentialFuture' ... done
[17:29:05.522] Future #1
[17:29:05.522]  length: 2 (resolved future 1)
[17:29:05.522] resolved() for 'SequentialFuture' ...
[17:29:05.523] - state: 'finished'
[17:29:05.523] - run: TRUE
[17:29:05.523] - result: 'FutureResult'
[17:29:05.523] resolved() for 'SequentialFuture' ... done
[17:29:05.523] Future #2
[17:29:05.524]  length: 1 (resolved future 2)
[17:29:05.524]  length: 0 (resolved future 3)
[17:29:05.524] resolve() on environment ... DONE
[17:29:05.524] resolved() for 'SequentialFuture' ...
[17:29:05.524] - state: 'finished'
[17:29:05.524] - run: TRUE
[17:29:05.525] - result: 'FutureResult'
[17:29:05.525] resolved() for 'SequentialFuture' ... done
[17:29:05.526] resolve() on environment ...
[17:29:05.526]  recursive: 0
[17:29:05.526]  elements: [3] 'b'
[17:29:05.526] resolved() for 'SequentialFuture' ...
[17:29:05.527] - state: 'finished'
[17:29:05.527] - run: TRUE
[17:29:05.527] - result: 'FutureResult'
[17:29:05.527] resolved() for 'SequentialFuture' ... done
[17:29:05.528] Future #1
[17:29:05.528]  length: 2 (resolved future 1)
[17:29:05.528] resolved() for 'SequentialFuture' ...
[17:29:05.528] - state: 'finished'
[17:29:05.528] - run: TRUE
[17:29:05.529] - result: 'FutureResult'
[17:29:05.529] resolved() for 'SequentialFuture' ... done
[17:29:05.529] Future #2
[17:29:05.529]  length: 1 (resolved future 2)
[17:29:05.529]  length: 0 (resolved future 3)
[17:29:05.530] resolve() on environment ... DONE
[17:29:05.530] resolve() on environment ...
[17:29:05.530]  recursive: 0
[17:29:05.531]  elements: [3] 'c'
[17:29:05.533] resolved() for 'SequentialFuture' ...
[17:29:05.533] - state: 'finished'
[17:29:05.533] - run: TRUE
[17:29:05.533] - result: 'FutureResult'
[17:29:05.533] resolved() for 'SequentialFuture' ... done
[17:29:05.534] Future #1
[17:29:05.534]  length: 2 (resolved future 1)
[17:29:05.534] resolved() for 'SequentialFuture' ...
[17:29:05.534] - state: 'finished'
[17:29:05.535] - run: TRUE
[17:29:05.535] - result: 'FutureResult'
[17:29:05.535] resolved() for 'SequentialFuture' ... done
[17:29:05.535] Future #2
[17:29:05.535]  length: 1 (resolved future 2)
[17:29:05.536]  length: 0 (resolved future 3)
[17:29:05.536] resolve() on environment ... DONE
[17:29:05.536] resolve() on environment ...
[17:29:05.537]  recursive: 0
[17:29:05.537]  elements: [3] 'a', 'b', 'c', '.future_b'
[17:29:05.537] resolved() for 'SequentialFuture' ...
[17:29:05.538] - state: 'finished'
[17:29:05.538] - run: TRUE
[17:29:05.538] - result: 'FutureResult'
[17:29:05.538] resolved() for 'SequentialFuture' ... done
[17:29:05.538] Future #1
[17:29:05.539]  length: 2 (resolved future 1)
[17:29:05.539] resolved() for 'SequentialFuture' ...
[17:29:05.539] - state: 'finished'
[17:29:05.540] - run: TRUE
[17:29:05.540] - result: 'FutureResult'
[17:29:05.540] resolved() for 'SequentialFuture' ... done
[17:29:05.540] Future #2
[17:29:05.540]  length: 1 (resolved future 2)
[17:29:05.541]  length: 0 (resolved future 3)
[17:29:05.541] resolve() on environment ... DONE
[17:29:05.541] resolve() on environment ...
[17:29:05.542]  recursive: 99
[17:29:05.542]  elements: [3] '.future_b', 'a', 'b', 'c'
[17:29:05.542] resolved() for 'SequentialFuture' ...
[17:29:05.543] - state: 'finished'
[17:29:05.543] - run: TRUE
[17:29:05.543] - result: 'FutureResult'
[17:29:05.543] resolved() for 'SequentialFuture' ... done
[17:29:05.543] Future #1
[17:29:05.544] resolved() for 'SequentialFuture' ...
[17:29:05.544] - state: 'finished'
[17:29:05.544] - run: TRUE
[17:29:05.544] - result: 'FutureResult'
[17:29:05.544] resolved() for 'SequentialFuture' ... done
[17:29:05.544] A SequentialFuture was resolved
[17:29:05.545]  length: 2 (resolved future 1)
[17:29:05.545] resolved() for 'SequentialFuture' ...
[17:29:05.545] - state: 'finished'
[17:29:05.545] - run: TRUE
[17:29:05.545] - result: 'FutureResult'
[17:29:05.546] resolved() for 'SequentialFuture' ... done
[17:29:05.546] Future #2
[17:29:05.546] resolved() for 'SequentialFuture' ...
[17:29:05.546] - state: 'finished'
[17:29:05.547] - run: TRUE
[17:29:05.547] - result: 'FutureResult'
[17:29:05.547] resolved() for 'SequentialFuture' ... done
[17:29:05.547] A SequentialFuture was resolved
[17:29:05.548]  length: 1 (resolved future 2)
[17:29:05.548]  length: 0 (resolved future 3)
[17:29:05.548] resolve() on environment ... DONE
*** resolve() for environments ... DONE
*** resolve() for list environments ...
[17:29:05.550] resolve() on list environment ...
[17:29:05.550]  recursive: 0
[17:29:05.552]  length: 2
[17:29:05.552]  elements: 'a', 'b'
[17:29:05.553]  length: 1 (resolved future 1)
[17:29:05.553]  length: 0 (resolved future 2)
[17:29:05.553] resolve() on list environment ... DONE
[17:29:05.553] getGlobalsAndPackages() ...
[17:29:05.554] Searching for globals...
[17:29:05.554] 
[17:29:05.555] Searching for globals ... DONE
[17:29:05.555] - globals: [0] <none>
[17:29:05.555] getGlobalsAndPackages() ... DONE
[17:29:05.556] run() for 'Future' ...
[17:29:05.556] - state: 'created'
[17:29:05.556] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:05.557] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:05.557] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:05.557]   - Field: 'label'
[17:29:05.558]   - Field: 'local'
[17:29:05.558]   - Field: 'owner'
[17:29:05.558]   - Field: 'envir'
[17:29:05.559]   - Field: 'packages'
[17:29:05.559]   - Field: 'gc'
[17:29:05.559]   - Field: 'conditions'
[17:29:05.559]   - Field: 'expr'
[17:29:05.560]   - Field: 'uuid'
[17:29:05.560]   - Field: 'seed'
[17:29:05.560]   - Field: 'version'
[17:29:05.561]   - Field: 'result'
[17:29:05.561]   - Field: 'asynchronous'
[17:29:05.561]   - Field: 'calls'
[17:29:05.561]   - Field: 'globals'
[17:29:05.562]   - Field: 'stdout'
[17:29:05.562]   - Field: 'earlySignal'
[17:29:05.562]   - Field: 'lazy'
[17:29:05.563]   - Field: 'state'
[17:29:05.563] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:05.563] - Launch lazy future ...
[17:29:05.564] Packages needed by the future expression (n = 0): <none>
[17:29:05.564] Packages needed by future strategies (n = 0): <none>
[17:29:05.565] {
[17:29:05.565]     {
[17:29:05.565]         {
[17:29:05.565]             ...future.startTime <- base::Sys.time()
[17:29:05.565]             {
[17:29:05.565]                 {
[17:29:05.565]                   {
[17:29:05.565]                     base::local({
[17:29:05.565]                       has_future <- base::requireNamespace("future", 
[17:29:05.565]                         quietly = TRUE)
[17:29:05.565]                       if (has_future) {
[17:29:05.565]                         ns <- base::getNamespace("future")
[17:29:05.565]                         version <- ns[[".package"]][["version"]]
[17:29:05.565]                         if (is.null(version)) 
[17:29:05.565]                           version <- utils::packageVersion("future")
[17:29:05.565]                       }
[17:29:05.565]                       else {
[17:29:05.565]                         version <- NULL
[17:29:05.565]                       }
[17:29:05.565]                       if (!has_future || version < "1.8.0") {
[17:29:05.565]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:05.565]                           "", base::R.version$version.string), 
[17:29:05.565]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:05.565]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:05.565]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:05.565]                             "release", "version")], collapse = " "), 
[17:29:05.565]                           hostname = base::Sys.info()[["nodename"]])
[17:29:05.565]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:05.565]                           info)
[17:29:05.565]                         info <- base::paste(info, collapse = "; ")
[17:29:05.565]                         if (!has_future) {
[17:29:05.565]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:05.565]                             info)
[17:29:05.565]                         }
[17:29:05.565]                         else {
[17:29:05.565]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:05.565]                             info, version)
[17:29:05.565]                         }
[17:29:05.565]                         base::stop(msg)
[17:29:05.565]                       }
[17:29:05.565]                     })
[17:29:05.565]                   }
[17:29:05.565]                   ...future.strategy.old <- future::plan("list")
[17:29:05.565]                   options(future.plan = NULL)
[17:29:05.565]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:05.565]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:05.565]                 }
[17:29:05.565]                 ...future.workdir <- getwd()
[17:29:05.565]             }
[17:29:05.565]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:05.565]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:05.565]         }
[17:29:05.565]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:05.565]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:05.565]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:05.565]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:05.565]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:05.565]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:05.565]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:05.565]             base::names(...future.oldOptions))
[17:29:05.565]     }
[17:29:05.565]     if (FALSE) {
[17:29:05.565]     }
[17:29:05.565]     else {
[17:29:05.565]         if (TRUE) {
[17:29:05.565]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:05.565]                 open = "w")
[17:29:05.565]         }
[17:29:05.565]         else {
[17:29:05.565]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:05.565]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:05.565]         }
[17:29:05.565]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:05.565]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:05.565]             base::sink(type = "output", split = FALSE)
[17:29:05.565]             base::close(...future.stdout)
[17:29:05.565]         }, add = TRUE)
[17:29:05.565]     }
[17:29:05.565]     ...future.frame <- base::sys.nframe()
[17:29:05.565]     ...future.conditions <- base::list()
[17:29:05.565]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:05.565]     if (FALSE) {
[17:29:05.565]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:05.565]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:05.565]     }
[17:29:05.565]     ...future.result <- base::tryCatch({
[17:29:05.565]         base::withCallingHandlers({
[17:29:05.565]             ...future.value <- base::withVisible(base::local(1))
[17:29:05.565]             future::FutureResult(value = ...future.value$value, 
[17:29:05.565]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:05.565]                   ...future.rng), globalenv = if (FALSE) 
[17:29:05.565]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:05.565]                     ...future.globalenv.names))
[17:29:05.565]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:05.565]         }, condition = base::local({
[17:29:05.565]             c <- base::c
[17:29:05.565]             inherits <- base::inherits
[17:29:05.565]             invokeRestart <- base::invokeRestart
[17:29:05.565]             length <- base::length
[17:29:05.565]             list <- base::list
[17:29:05.565]             seq.int <- base::seq.int
[17:29:05.565]             signalCondition <- base::signalCondition
[17:29:05.565]             sys.calls <- base::sys.calls
[17:29:05.565]             `[[` <- base::`[[`
[17:29:05.565]             `+` <- base::`+`
[17:29:05.565]             `<<-` <- base::`<<-`
[17:29:05.565]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:05.565]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:05.565]                   3L)]
[17:29:05.565]             }
[17:29:05.565]             function(cond) {
[17:29:05.565]                 is_error <- inherits(cond, "error")
[17:29:05.565]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:05.565]                   NULL)
[17:29:05.565]                 if (is_error) {
[17:29:05.565]                   sessionInformation <- function() {
[17:29:05.565]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:05.565]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:05.565]                       search = base::search(), system = base::Sys.info())
[17:29:05.565]                   }
[17:29:05.565]                   ...future.conditions[[length(...future.conditions) + 
[17:29:05.565]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:05.565]                     cond$call), session = sessionInformation(), 
[17:29:05.565]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:05.565]                   signalCondition(cond)
[17:29:05.565]                 }
[17:29:05.565]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:05.565]                 "immediateCondition"))) {
[17:29:05.565]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:05.565]                   ...future.conditions[[length(...future.conditions) + 
[17:29:05.565]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:05.565]                   if (TRUE && !signal) {
[17:29:05.565]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:05.565]                     {
[17:29:05.565]                       inherits <- base::inherits
[17:29:05.565]                       invokeRestart <- base::invokeRestart
[17:29:05.565]                       is.null <- base::is.null
[17:29:05.565]                       muffled <- FALSE
[17:29:05.565]                       if (inherits(cond, "message")) {
[17:29:05.565]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:05.565]                         if (muffled) 
[17:29:05.565]                           invokeRestart("muffleMessage")
[17:29:05.565]                       }
[17:29:05.565]                       else if (inherits(cond, "warning")) {
[17:29:05.565]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:05.565]                         if (muffled) 
[17:29:05.565]                           invokeRestart("muffleWarning")
[17:29:05.565]                       }
[17:29:05.565]                       else if (inherits(cond, "condition")) {
[17:29:05.565]                         if (!is.null(pattern)) {
[17:29:05.565]                           computeRestarts <- base::computeRestarts
[17:29:05.565]                           grepl <- base::grepl
[17:29:05.565]                           restarts <- computeRestarts(cond)
[17:29:05.565]                           for (restart in restarts) {
[17:29:05.565]                             name <- restart$name
[17:29:05.565]                             if (is.null(name)) 
[17:29:05.565]                               next
[17:29:05.565]                             if (!grepl(pattern, name)) 
[17:29:05.565]                               next
[17:29:05.565]                             invokeRestart(restart)
[17:29:05.565]                             muffled <- TRUE
[17:29:05.565]                             break
[17:29:05.565]                           }
[17:29:05.565]                         }
[17:29:05.565]                       }
[17:29:05.565]                       invisible(muffled)
[17:29:05.565]                     }
[17:29:05.565]                     muffleCondition(cond, pattern = "^muffle")
[17:29:05.565]                   }
[17:29:05.565]                 }
[17:29:05.565]                 else {
[17:29:05.565]                   if (TRUE) {
[17:29:05.565]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:05.565]                     {
[17:29:05.565]                       inherits <- base::inherits
[17:29:05.565]                       invokeRestart <- base::invokeRestart
[17:29:05.565]                       is.null <- base::is.null
[17:29:05.565]                       muffled <- FALSE
[17:29:05.565]                       if (inherits(cond, "message")) {
[17:29:05.565]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:05.565]                         if (muffled) 
[17:29:05.565]                           invokeRestart("muffleMessage")
[17:29:05.565]                       }
[17:29:05.565]                       else if (inherits(cond, "warning")) {
[17:29:05.565]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:05.565]                         if (muffled) 
[17:29:05.565]                           invokeRestart("muffleWarning")
[17:29:05.565]                       }
[17:29:05.565]                       else if (inherits(cond, "condition")) {
[17:29:05.565]                         if (!is.null(pattern)) {
[17:29:05.565]                           computeRestarts <- base::computeRestarts
[17:29:05.565]                           grepl <- base::grepl
[17:29:05.565]                           restarts <- computeRestarts(cond)
[17:29:05.565]                           for (restart in restarts) {
[17:29:05.565]                             name <- restart$name
[17:29:05.565]                             if (is.null(name)) 
[17:29:05.565]                               next
[17:29:05.565]                             if (!grepl(pattern, name)) 
[17:29:05.565]                               next
[17:29:05.565]                             invokeRestart(restart)
[17:29:05.565]                             muffled <- TRUE
[17:29:05.565]                             break
[17:29:05.565]                           }
[17:29:05.565]                         }
[17:29:05.565]                       }
[17:29:05.565]                       invisible(muffled)
[17:29:05.565]                     }
[17:29:05.565]                     muffleCondition(cond, pattern = "^muffle")
[17:29:05.565]                   }
[17:29:05.565]                 }
[17:29:05.565]             }
[17:29:05.565]         }))
[17:29:05.565]     }, error = function(ex) {
[17:29:05.565]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:05.565]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:05.565]                 ...future.rng), started = ...future.startTime, 
[17:29:05.565]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:05.565]             version = "1.8"), class = "FutureResult")
[17:29:05.565]     }, finally = {
[17:29:05.565]         if (!identical(...future.workdir, getwd())) 
[17:29:05.565]             setwd(...future.workdir)
[17:29:05.565]         {
[17:29:05.565]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:05.565]                 ...future.oldOptions$nwarnings <- NULL
[17:29:05.565]             }
[17:29:05.565]             base::options(...future.oldOptions)
[17:29:05.565]             if (.Platform$OS.type == "windows") {
[17:29:05.565]                 old_names <- names(...future.oldEnvVars)
[17:29:05.565]                 envs <- base::Sys.getenv()
[17:29:05.565]                 names <- names(envs)
[17:29:05.565]                 common <- intersect(names, old_names)
[17:29:05.565]                 added <- setdiff(names, old_names)
[17:29:05.565]                 removed <- setdiff(old_names, names)
[17:29:05.565]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:05.565]                   envs[common]]
[17:29:05.565]                 NAMES <- toupper(changed)
[17:29:05.565]                 args <- list()
[17:29:05.565]                 for (kk in seq_along(NAMES)) {
[17:29:05.565]                   name <- changed[[kk]]
[17:29:05.565]                   NAME <- NAMES[[kk]]
[17:29:05.565]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.565]                     next
[17:29:05.565]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:05.565]                 }
[17:29:05.565]                 NAMES <- toupper(added)
[17:29:05.565]                 for (kk in seq_along(NAMES)) {
[17:29:05.565]                   name <- added[[kk]]
[17:29:05.565]                   NAME <- NAMES[[kk]]
[17:29:05.565]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.565]                     next
[17:29:05.565]                   args[[name]] <- ""
[17:29:05.565]                 }
[17:29:05.565]                 NAMES <- toupper(removed)
[17:29:05.565]                 for (kk in seq_along(NAMES)) {
[17:29:05.565]                   name <- removed[[kk]]
[17:29:05.565]                   NAME <- NAMES[[kk]]
[17:29:05.565]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.565]                     next
[17:29:05.565]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:05.565]                 }
[17:29:05.565]                 if (length(args) > 0) 
[17:29:05.565]                   base::do.call(base::Sys.setenv, args = args)
[17:29:05.565]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:05.565]             }
[17:29:05.565]             else {
[17:29:05.565]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:05.565]             }
[17:29:05.565]             {
[17:29:05.565]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:05.565]                   0L) {
[17:29:05.565]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:05.565]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:05.565]                   base::options(opts)
[17:29:05.565]                 }
[17:29:05.565]                 {
[17:29:05.565]                   {
[17:29:05.565]                     NULL
[17:29:05.565]                     RNGkind("Mersenne-Twister")
[17:29:05.565]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:05.565]                       inherits = FALSE)
[17:29:05.565]                   }
[17:29:05.565]                   options(future.plan = NULL)
[17:29:05.565]                   if (is.na(NA_character_)) 
[17:29:05.565]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:05.565]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:05.565]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:05.565]                     .init = FALSE)
[17:29:05.565]                 }
[17:29:05.565]             }
[17:29:05.565]         }
[17:29:05.565]     })
[17:29:05.565]     if (TRUE) {
[17:29:05.565]         base::sink(type = "output", split = FALSE)
[17:29:05.565]         if (TRUE) {
[17:29:05.565]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:05.565]         }
[17:29:05.565]         else {
[17:29:05.565]             ...future.result["stdout"] <- base::list(NULL)
[17:29:05.565]         }
[17:29:05.565]         base::close(...future.stdout)
[17:29:05.565]         ...future.stdout <- NULL
[17:29:05.565]     }
[17:29:05.565]     ...future.result$conditions <- ...future.conditions
[17:29:05.565]     ...future.result$finished <- base::Sys.time()
[17:29:05.565]     ...future.result
[17:29:05.565] }
[17:29:05.570] plan(): Setting new future strategy stack:
[17:29:05.570] List of future strategies:
[17:29:05.570] 1. sequential:
[17:29:05.570]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:05.570]    - tweaked: FALSE
[17:29:05.570]    - call: NULL
[17:29:05.571] plan(): nbrOfWorkers() = 1
[17:29:05.572] plan(): Setting new future strategy stack:
[17:29:05.572] List of future strategies:
[17:29:05.572] 1. sequential:
[17:29:05.572]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:05.572]    - tweaked: FALSE
[17:29:05.572]    - call: plan(strategy)
[17:29:05.573] plan(): nbrOfWorkers() = 1
[17:29:05.573] SequentialFuture started (and completed)
[17:29:05.573] - Launch lazy future ... done
[17:29:05.573] run() for 'SequentialFuture' ... done
[17:29:05.574] getGlobalsAndPackages() ...
[17:29:05.574] Searching for globals...
[17:29:05.574] 
[17:29:05.574] Searching for globals ... DONE
[17:29:05.575] - globals: [0] <none>
[17:29:05.575] getGlobalsAndPackages() ... DONE
[17:29:05.577] run() for 'Future' ...
[17:29:05.577] - state: 'created'
[17:29:05.577] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:05.578] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:05.578] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:05.578]   - Field: 'label'
[17:29:05.578]   - Field: 'local'
[17:29:05.578]   - Field: 'owner'
[17:29:05.579]   - Field: 'envir'
[17:29:05.579]   - Field: 'packages'
[17:29:05.579]   - Field: 'gc'
[17:29:05.579]   - Field: 'conditions'
[17:29:05.579]   - Field: 'expr'
[17:29:05.580]   - Field: 'uuid'
[17:29:05.580]   - Field: 'seed'
[17:29:05.580]   - Field: 'version'
[17:29:05.580]   - Field: 'result'
[17:29:05.580]   - Field: 'asynchronous'
[17:29:05.581]   - Field: 'calls'
[17:29:05.581]   - Field: 'globals'
[17:29:05.581]   - Field: 'stdout'
[17:29:05.581]   - Field: 'earlySignal'
[17:29:05.581]   - Field: 'lazy'
[17:29:05.582]   - Field: 'state'
[17:29:05.582] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:05.582] - Launch lazy future ...
[17:29:05.582] Packages needed by the future expression (n = 0): <none>
[17:29:05.582] Packages needed by future strategies (n = 0): <none>
[17:29:05.583] {
[17:29:05.583]     {
[17:29:05.583]         {
[17:29:05.583]             ...future.startTime <- base::Sys.time()
[17:29:05.583]             {
[17:29:05.583]                 {
[17:29:05.583]                   {
[17:29:05.583]                     base::local({
[17:29:05.583]                       has_future <- base::requireNamespace("future", 
[17:29:05.583]                         quietly = TRUE)
[17:29:05.583]                       if (has_future) {
[17:29:05.583]                         ns <- base::getNamespace("future")
[17:29:05.583]                         version <- ns[[".package"]][["version"]]
[17:29:05.583]                         if (is.null(version)) 
[17:29:05.583]                           version <- utils::packageVersion("future")
[17:29:05.583]                       }
[17:29:05.583]                       else {
[17:29:05.583]                         version <- NULL
[17:29:05.583]                       }
[17:29:05.583]                       if (!has_future || version < "1.8.0") {
[17:29:05.583]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:05.583]                           "", base::R.version$version.string), 
[17:29:05.583]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:05.583]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:05.583]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:05.583]                             "release", "version")], collapse = " "), 
[17:29:05.583]                           hostname = base::Sys.info()[["nodename"]])
[17:29:05.583]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:05.583]                           info)
[17:29:05.583]                         info <- base::paste(info, collapse = "; ")
[17:29:05.583]                         if (!has_future) {
[17:29:05.583]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:05.583]                             info)
[17:29:05.583]                         }
[17:29:05.583]                         else {
[17:29:05.583]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:05.583]                             info, version)
[17:29:05.583]                         }
[17:29:05.583]                         base::stop(msg)
[17:29:05.583]                       }
[17:29:05.583]                     })
[17:29:05.583]                   }
[17:29:05.583]                   ...future.strategy.old <- future::plan("list")
[17:29:05.583]                   options(future.plan = NULL)
[17:29:05.583]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:05.583]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:05.583]                 }
[17:29:05.583]                 ...future.workdir <- getwd()
[17:29:05.583]             }
[17:29:05.583]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:05.583]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:05.583]         }
[17:29:05.583]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:05.583]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:05.583]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:05.583]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:05.583]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:05.583]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:05.583]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:05.583]             base::names(...future.oldOptions))
[17:29:05.583]     }
[17:29:05.583]     if (FALSE) {
[17:29:05.583]     }
[17:29:05.583]     else {
[17:29:05.583]         if (TRUE) {
[17:29:05.583]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:05.583]                 open = "w")
[17:29:05.583]         }
[17:29:05.583]         else {
[17:29:05.583]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:05.583]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:05.583]         }
[17:29:05.583]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:05.583]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:05.583]             base::sink(type = "output", split = FALSE)
[17:29:05.583]             base::close(...future.stdout)
[17:29:05.583]         }, add = TRUE)
[17:29:05.583]     }
[17:29:05.583]     ...future.frame <- base::sys.nframe()
[17:29:05.583]     ...future.conditions <- base::list()
[17:29:05.583]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:05.583]     if (FALSE) {
[17:29:05.583]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:05.583]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:05.583]     }
[17:29:05.583]     ...future.result <- base::tryCatch({
[17:29:05.583]         base::withCallingHandlers({
[17:29:05.583]             ...future.value <- base::withVisible(base::local(2))
[17:29:05.583]             future::FutureResult(value = ...future.value$value, 
[17:29:05.583]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:05.583]                   ...future.rng), globalenv = if (FALSE) 
[17:29:05.583]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:05.583]                     ...future.globalenv.names))
[17:29:05.583]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:05.583]         }, condition = base::local({
[17:29:05.583]             c <- base::c
[17:29:05.583]             inherits <- base::inherits
[17:29:05.583]             invokeRestart <- base::invokeRestart
[17:29:05.583]             length <- base::length
[17:29:05.583]             list <- base::list
[17:29:05.583]             seq.int <- base::seq.int
[17:29:05.583]             signalCondition <- base::signalCondition
[17:29:05.583]             sys.calls <- base::sys.calls
[17:29:05.583]             `[[` <- base::`[[`
[17:29:05.583]             `+` <- base::`+`
[17:29:05.583]             `<<-` <- base::`<<-`
[17:29:05.583]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:05.583]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:05.583]                   3L)]
[17:29:05.583]             }
[17:29:05.583]             function(cond) {
[17:29:05.583]                 is_error <- inherits(cond, "error")
[17:29:05.583]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:05.583]                   NULL)
[17:29:05.583]                 if (is_error) {
[17:29:05.583]                   sessionInformation <- function() {
[17:29:05.583]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:05.583]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:05.583]                       search = base::search(), system = base::Sys.info())
[17:29:05.583]                   }
[17:29:05.583]                   ...future.conditions[[length(...future.conditions) + 
[17:29:05.583]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:05.583]                     cond$call), session = sessionInformation(), 
[17:29:05.583]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:05.583]                   signalCondition(cond)
[17:29:05.583]                 }
[17:29:05.583]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:05.583]                 "immediateCondition"))) {
[17:29:05.583]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:05.583]                   ...future.conditions[[length(...future.conditions) + 
[17:29:05.583]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:05.583]                   if (TRUE && !signal) {
[17:29:05.583]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:05.583]                     {
[17:29:05.583]                       inherits <- base::inherits
[17:29:05.583]                       invokeRestart <- base::invokeRestart
[17:29:05.583]                       is.null <- base::is.null
[17:29:05.583]                       muffled <- FALSE
[17:29:05.583]                       if (inherits(cond, "message")) {
[17:29:05.583]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:05.583]                         if (muffled) 
[17:29:05.583]                           invokeRestart("muffleMessage")
[17:29:05.583]                       }
[17:29:05.583]                       else if (inherits(cond, "warning")) {
[17:29:05.583]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:05.583]                         if (muffled) 
[17:29:05.583]                           invokeRestart("muffleWarning")
[17:29:05.583]                       }
[17:29:05.583]                       else if (inherits(cond, "condition")) {
[17:29:05.583]                         if (!is.null(pattern)) {
[17:29:05.583]                           computeRestarts <- base::computeRestarts
[17:29:05.583]                           grepl <- base::grepl
[17:29:05.583]                           restarts <- computeRestarts(cond)
[17:29:05.583]                           for (restart in restarts) {
[17:29:05.583]                             name <- restart$name
[17:29:05.583]                             if (is.null(name)) 
[17:29:05.583]                               next
[17:29:05.583]                             if (!grepl(pattern, name)) 
[17:29:05.583]                               next
[17:29:05.583]                             invokeRestart(restart)
[17:29:05.583]                             muffled <- TRUE
[17:29:05.583]                             break
[17:29:05.583]                           }
[17:29:05.583]                         }
[17:29:05.583]                       }
[17:29:05.583]                       invisible(muffled)
[17:29:05.583]                     }
[17:29:05.583]                     muffleCondition(cond, pattern = "^muffle")
[17:29:05.583]                   }
[17:29:05.583]                 }
[17:29:05.583]                 else {
[17:29:05.583]                   if (TRUE) {
[17:29:05.583]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:05.583]                     {
[17:29:05.583]                       inherits <- base::inherits
[17:29:05.583]                       invokeRestart <- base::invokeRestart
[17:29:05.583]                       is.null <- base::is.null
[17:29:05.583]                       muffled <- FALSE
[17:29:05.583]                       if (inherits(cond, "message")) {
[17:29:05.583]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:05.583]                         if (muffled) 
[17:29:05.583]                           invokeRestart("muffleMessage")
[17:29:05.583]                       }
[17:29:05.583]                       else if (inherits(cond, "warning")) {
[17:29:05.583]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:05.583]                         if (muffled) 
[17:29:05.583]                           invokeRestart("muffleWarning")
[17:29:05.583]                       }
[17:29:05.583]                       else if (inherits(cond, "condition")) {
[17:29:05.583]                         if (!is.null(pattern)) {
[17:29:05.583]                           computeRestarts <- base::computeRestarts
[17:29:05.583]                           grepl <- base::grepl
[17:29:05.583]                           restarts <- computeRestarts(cond)
[17:29:05.583]                           for (restart in restarts) {
[17:29:05.583]                             name <- restart$name
[17:29:05.583]                             if (is.null(name)) 
[17:29:05.583]                               next
[17:29:05.583]                             if (!grepl(pattern, name)) 
[17:29:05.583]                               next
[17:29:05.583]                             invokeRestart(restart)
[17:29:05.583]                             muffled <- TRUE
[17:29:05.583]                             break
[17:29:05.583]                           }
[17:29:05.583]                         }
[17:29:05.583]                       }
[17:29:05.583]                       invisible(muffled)
[17:29:05.583]                     }
[17:29:05.583]                     muffleCondition(cond, pattern = "^muffle")
[17:29:05.583]                   }
[17:29:05.583]                 }
[17:29:05.583]             }
[17:29:05.583]         }))
[17:29:05.583]     }, error = function(ex) {
[17:29:05.583]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:05.583]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:05.583]                 ...future.rng), started = ...future.startTime, 
[17:29:05.583]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:05.583]             version = "1.8"), class = "FutureResult")
[17:29:05.583]     }, finally = {
[17:29:05.583]         if (!identical(...future.workdir, getwd())) 
[17:29:05.583]             setwd(...future.workdir)
[17:29:05.583]         {
[17:29:05.583]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:05.583]                 ...future.oldOptions$nwarnings <- NULL
[17:29:05.583]             }
[17:29:05.583]             base::options(...future.oldOptions)
[17:29:05.583]             if (.Platform$OS.type == "windows") {
[17:29:05.583]                 old_names <- names(...future.oldEnvVars)
[17:29:05.583]                 envs <- base::Sys.getenv()
[17:29:05.583]                 names <- names(envs)
[17:29:05.583]                 common <- intersect(names, old_names)
[17:29:05.583]                 added <- setdiff(names, old_names)
[17:29:05.583]                 removed <- setdiff(old_names, names)
[17:29:05.583]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:05.583]                   envs[common]]
[17:29:05.583]                 NAMES <- toupper(changed)
[17:29:05.583]                 args <- list()
[17:29:05.583]                 for (kk in seq_along(NAMES)) {
[17:29:05.583]                   name <- changed[[kk]]
[17:29:05.583]                   NAME <- NAMES[[kk]]
[17:29:05.583]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.583]                     next
[17:29:05.583]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:05.583]                 }
[17:29:05.583]                 NAMES <- toupper(added)
[17:29:05.583]                 for (kk in seq_along(NAMES)) {
[17:29:05.583]                   name <- added[[kk]]
[17:29:05.583]                   NAME <- NAMES[[kk]]
[17:29:05.583]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.583]                     next
[17:29:05.583]                   args[[name]] <- ""
[17:29:05.583]                 }
[17:29:05.583]                 NAMES <- toupper(removed)
[17:29:05.583]                 for (kk in seq_along(NAMES)) {
[17:29:05.583]                   name <- removed[[kk]]
[17:29:05.583]                   NAME <- NAMES[[kk]]
[17:29:05.583]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.583]                     next
[17:29:05.583]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:05.583]                 }
[17:29:05.583]                 if (length(args) > 0) 
[17:29:05.583]                   base::do.call(base::Sys.setenv, args = args)
[17:29:05.583]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:05.583]             }
[17:29:05.583]             else {
[17:29:05.583]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:05.583]             }
[17:29:05.583]             {
[17:29:05.583]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:05.583]                   0L) {
[17:29:05.583]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:05.583]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:05.583]                   base::options(opts)
[17:29:05.583]                 }
[17:29:05.583]                 {
[17:29:05.583]                   {
[17:29:05.583]                     NULL
[17:29:05.583]                     RNGkind("Mersenne-Twister")
[17:29:05.583]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:05.583]                       inherits = FALSE)
[17:29:05.583]                   }
[17:29:05.583]                   options(future.plan = NULL)
[17:29:05.583]                   if (is.na(NA_character_)) 
[17:29:05.583]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:05.583]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:05.583]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:05.583]                     .init = FALSE)
[17:29:05.583]                 }
[17:29:05.583]             }
[17:29:05.583]         }
[17:29:05.583]     })
[17:29:05.583]     if (TRUE) {
[17:29:05.583]         base::sink(type = "output", split = FALSE)
[17:29:05.583]         if (TRUE) {
[17:29:05.583]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:05.583]         }
[17:29:05.583]         else {
[17:29:05.583]             ...future.result["stdout"] <- base::list(NULL)
[17:29:05.583]         }
[17:29:05.583]         base::close(...future.stdout)
[17:29:05.583]         ...future.stdout <- NULL
[17:29:05.583]     }
[17:29:05.583]     ...future.result$conditions <- ...future.conditions
[17:29:05.583]     ...future.result$finished <- base::Sys.time()
[17:29:05.583]     ...future.result
[17:29:05.583] }
[17:29:05.587] plan(): Setting new future strategy stack:
[17:29:05.587] List of future strategies:
[17:29:05.587] 1. sequential:
[17:29:05.587]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:05.587]    - tweaked: FALSE
[17:29:05.587]    - call: NULL
[17:29:05.588] plan(): nbrOfWorkers() = 1
[17:29:05.589] plan(): Setting new future strategy stack:
[17:29:05.589] List of future strategies:
[17:29:05.589] 1. sequential:
[17:29:05.589]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:05.589]    - tweaked: FALSE
[17:29:05.589]    - call: plan(strategy)
[17:29:05.590] plan(): nbrOfWorkers() = 1
[17:29:05.590] SequentialFuture started (and completed)
[17:29:05.590] - Launch lazy future ... done
[17:29:05.590] run() for 'SequentialFuture' ... done
[17:29:05.591] resolve() on list environment ...
[17:29:05.591]  recursive: 0
[17:29:05.592]  length: 3
[17:29:05.592]  elements: 'a', 'b', 'c'
[17:29:05.593] resolved() for 'SequentialFuture' ...
[17:29:05.593] - state: 'finished'
[17:29:05.593] - run: TRUE
[17:29:05.593] - result: 'FutureResult'
[17:29:05.593] resolved() for 'SequentialFuture' ... done
[17:29:05.593] Future #1
[17:29:05.594]  length: 2 (resolved future 1)
[17:29:05.594] resolved() for 'SequentialFuture' ...
[17:29:05.594] - state: 'finished'
[17:29:05.594] - run: TRUE
[17:29:05.594] - result: 'FutureResult'
[17:29:05.595] resolved() for 'SequentialFuture' ... done
[17:29:05.595] Future #2
[17:29:05.595]  length: 1 (resolved future 2)
[17:29:05.595]  length: 0 (resolved future 3)
[17:29:05.595] resolve() on list environment ... DONE
[17:29:05.596] getGlobalsAndPackages() ...
[17:29:05.597] Searching for globals...
[17:29:05.599] - globals found: [1] '{'
[17:29:05.600] Searching for globals ... DONE
[17:29:05.600] Resolving globals: FALSE
[17:29:05.601] 
[17:29:05.601] 
[17:29:05.601] getGlobalsAndPackages() ... DONE
[17:29:05.602] run() for 'Future' ...
[17:29:05.603] - state: 'created'
[17:29:05.603] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:05.604] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:05.604] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:05.604]   - Field: 'label'
[17:29:05.605]   - Field: 'local'
[17:29:05.605]   - Field: 'owner'
[17:29:05.605]   - Field: 'envir'
[17:29:05.606]   - Field: 'packages'
[17:29:05.606]   - Field: 'gc'
[17:29:05.606]   - Field: 'conditions'
[17:29:05.607]   - Field: 'expr'
[17:29:05.607]   - Field: 'uuid'
[17:29:05.607]   - Field: 'seed'
[17:29:05.608]   - Field: 'version'
[17:29:05.608]   - Field: 'result'
[17:29:05.608]   - Field: 'asynchronous'
[17:29:05.609]   - Field: 'calls'
[17:29:05.609]   - Field: 'globals'
[17:29:05.610]   - Field: 'stdout'
[17:29:05.610]   - Field: 'earlySignal'
[17:29:05.610]   - Field: 'lazy'
[17:29:05.611]   - Field: 'state'
[17:29:05.611] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:05.611] - Launch lazy future ...
[17:29:05.612] Packages needed by the future expression (n = 0): <none>
[17:29:05.612] Packages needed by future strategies (n = 0): <none>
[17:29:05.613] {
[17:29:05.613]     {
[17:29:05.613]         {
[17:29:05.613]             ...future.startTime <- base::Sys.time()
[17:29:05.613]             {
[17:29:05.613]                 {
[17:29:05.613]                   {
[17:29:05.613]                     base::local({
[17:29:05.613]                       has_future <- base::requireNamespace("future", 
[17:29:05.613]                         quietly = TRUE)
[17:29:05.613]                       if (has_future) {
[17:29:05.613]                         ns <- base::getNamespace("future")
[17:29:05.613]                         version <- ns[[".package"]][["version"]]
[17:29:05.613]                         if (is.null(version)) 
[17:29:05.613]                           version <- utils::packageVersion("future")
[17:29:05.613]                       }
[17:29:05.613]                       else {
[17:29:05.613]                         version <- NULL
[17:29:05.613]                       }
[17:29:05.613]                       if (!has_future || version < "1.8.0") {
[17:29:05.613]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:05.613]                           "", base::R.version$version.string), 
[17:29:05.613]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:05.613]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:05.613]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:05.613]                             "release", "version")], collapse = " "), 
[17:29:05.613]                           hostname = base::Sys.info()[["nodename"]])
[17:29:05.613]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:05.613]                           info)
[17:29:05.613]                         info <- base::paste(info, collapse = "; ")
[17:29:05.613]                         if (!has_future) {
[17:29:05.613]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:05.613]                             info)
[17:29:05.613]                         }
[17:29:05.613]                         else {
[17:29:05.613]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:05.613]                             info, version)
[17:29:05.613]                         }
[17:29:05.613]                         base::stop(msg)
[17:29:05.613]                       }
[17:29:05.613]                     })
[17:29:05.613]                   }
[17:29:05.613]                   ...future.strategy.old <- future::plan("list")
[17:29:05.613]                   options(future.plan = NULL)
[17:29:05.613]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:05.613]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:05.613]                 }
[17:29:05.613]                 ...future.workdir <- getwd()
[17:29:05.613]             }
[17:29:05.613]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:05.613]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:05.613]         }
[17:29:05.613]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:05.613]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:05.613]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:05.613]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:05.613]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:05.613]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:05.613]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:05.613]             base::names(...future.oldOptions))
[17:29:05.613]     }
[17:29:05.613]     if (FALSE) {
[17:29:05.613]     }
[17:29:05.613]     else {
[17:29:05.613]         if (TRUE) {
[17:29:05.613]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:05.613]                 open = "w")
[17:29:05.613]         }
[17:29:05.613]         else {
[17:29:05.613]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:05.613]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:05.613]         }
[17:29:05.613]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:05.613]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:05.613]             base::sink(type = "output", split = FALSE)
[17:29:05.613]             base::close(...future.stdout)
[17:29:05.613]         }, add = TRUE)
[17:29:05.613]     }
[17:29:05.613]     ...future.frame <- base::sys.nframe()
[17:29:05.613]     ...future.conditions <- base::list()
[17:29:05.613]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:05.613]     if (FALSE) {
[17:29:05.613]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:05.613]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:05.613]     }
[17:29:05.613]     ...future.result <- base::tryCatch({
[17:29:05.613]         base::withCallingHandlers({
[17:29:05.613]             ...future.value <- base::withVisible(base::local({
[17:29:05.613]                 1
[17:29:05.613]             }))
[17:29:05.613]             future::FutureResult(value = ...future.value$value, 
[17:29:05.613]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:05.613]                   ...future.rng), globalenv = if (FALSE) 
[17:29:05.613]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:05.613]                     ...future.globalenv.names))
[17:29:05.613]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:05.613]         }, condition = base::local({
[17:29:05.613]             c <- base::c
[17:29:05.613]             inherits <- base::inherits
[17:29:05.613]             invokeRestart <- base::invokeRestart
[17:29:05.613]             length <- base::length
[17:29:05.613]             list <- base::list
[17:29:05.613]             seq.int <- base::seq.int
[17:29:05.613]             signalCondition <- base::signalCondition
[17:29:05.613]             sys.calls <- base::sys.calls
[17:29:05.613]             `[[` <- base::`[[`
[17:29:05.613]             `+` <- base::`+`
[17:29:05.613]             `<<-` <- base::`<<-`
[17:29:05.613]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:05.613]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:05.613]                   3L)]
[17:29:05.613]             }
[17:29:05.613]             function(cond) {
[17:29:05.613]                 is_error <- inherits(cond, "error")
[17:29:05.613]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:05.613]                   NULL)
[17:29:05.613]                 if (is_error) {
[17:29:05.613]                   sessionInformation <- function() {
[17:29:05.613]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:05.613]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:05.613]                       search = base::search(), system = base::Sys.info())
[17:29:05.613]                   }
[17:29:05.613]                   ...future.conditions[[length(...future.conditions) + 
[17:29:05.613]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:05.613]                     cond$call), session = sessionInformation(), 
[17:29:05.613]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:05.613]                   signalCondition(cond)
[17:29:05.613]                 }
[17:29:05.613]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:05.613]                 "immediateCondition"))) {
[17:29:05.613]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:05.613]                   ...future.conditions[[length(...future.conditions) + 
[17:29:05.613]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:05.613]                   if (TRUE && !signal) {
[17:29:05.613]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:05.613]                     {
[17:29:05.613]                       inherits <- base::inherits
[17:29:05.613]                       invokeRestart <- base::invokeRestart
[17:29:05.613]                       is.null <- base::is.null
[17:29:05.613]                       muffled <- FALSE
[17:29:05.613]                       if (inherits(cond, "message")) {
[17:29:05.613]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:05.613]                         if (muffled) 
[17:29:05.613]                           invokeRestart("muffleMessage")
[17:29:05.613]                       }
[17:29:05.613]                       else if (inherits(cond, "warning")) {
[17:29:05.613]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:05.613]                         if (muffled) 
[17:29:05.613]                           invokeRestart("muffleWarning")
[17:29:05.613]                       }
[17:29:05.613]                       else if (inherits(cond, "condition")) {
[17:29:05.613]                         if (!is.null(pattern)) {
[17:29:05.613]                           computeRestarts <- base::computeRestarts
[17:29:05.613]                           grepl <- base::grepl
[17:29:05.613]                           restarts <- computeRestarts(cond)
[17:29:05.613]                           for (restart in restarts) {
[17:29:05.613]                             name <- restart$name
[17:29:05.613]                             if (is.null(name)) 
[17:29:05.613]                               next
[17:29:05.613]                             if (!grepl(pattern, name)) 
[17:29:05.613]                               next
[17:29:05.613]                             invokeRestart(restart)
[17:29:05.613]                             muffled <- TRUE
[17:29:05.613]                             break
[17:29:05.613]                           }
[17:29:05.613]                         }
[17:29:05.613]                       }
[17:29:05.613]                       invisible(muffled)
[17:29:05.613]                     }
[17:29:05.613]                     muffleCondition(cond, pattern = "^muffle")
[17:29:05.613]                   }
[17:29:05.613]                 }
[17:29:05.613]                 else {
[17:29:05.613]                   if (TRUE) {
[17:29:05.613]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:05.613]                     {
[17:29:05.613]                       inherits <- base::inherits
[17:29:05.613]                       invokeRestart <- base::invokeRestart
[17:29:05.613]                       is.null <- base::is.null
[17:29:05.613]                       muffled <- FALSE
[17:29:05.613]                       if (inherits(cond, "message")) {
[17:29:05.613]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:05.613]                         if (muffled) 
[17:29:05.613]                           invokeRestart("muffleMessage")
[17:29:05.613]                       }
[17:29:05.613]                       else if (inherits(cond, "warning")) {
[17:29:05.613]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:05.613]                         if (muffled) 
[17:29:05.613]                           invokeRestart("muffleWarning")
[17:29:05.613]                       }
[17:29:05.613]                       else if (inherits(cond, "condition")) {
[17:29:05.613]                         if (!is.null(pattern)) {
[17:29:05.613]                           computeRestarts <- base::computeRestarts
[17:29:05.613]                           grepl <- base::grepl
[17:29:05.613]                           restarts <- computeRestarts(cond)
[17:29:05.613]                           for (restart in restarts) {
[17:29:05.613]                             name <- restart$name
[17:29:05.613]                             if (is.null(name)) 
[17:29:05.613]                               next
[17:29:05.613]                             if (!grepl(pattern, name)) 
[17:29:05.613]                               next
[17:29:05.613]                             invokeRestart(restart)
[17:29:05.613]                             muffled <- TRUE
[17:29:05.613]                             break
[17:29:05.613]                           }
[17:29:05.613]                         }
[17:29:05.613]                       }
[17:29:05.613]                       invisible(muffled)
[17:29:05.613]                     }
[17:29:05.613]                     muffleCondition(cond, pattern = "^muffle")
[17:29:05.613]                   }
[17:29:05.613]                 }
[17:29:05.613]             }
[17:29:05.613]         }))
[17:29:05.613]     }, error = function(ex) {
[17:29:05.613]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:05.613]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:05.613]                 ...future.rng), started = ...future.startTime, 
[17:29:05.613]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:05.613]             version = "1.8"), class = "FutureResult")
[17:29:05.613]     }, finally = {
[17:29:05.613]         if (!identical(...future.workdir, getwd())) 
[17:29:05.613]             setwd(...future.workdir)
[17:29:05.613]         {
[17:29:05.613]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:05.613]                 ...future.oldOptions$nwarnings <- NULL
[17:29:05.613]             }
[17:29:05.613]             base::options(...future.oldOptions)
[17:29:05.613]             if (.Platform$OS.type == "windows") {
[17:29:05.613]                 old_names <- names(...future.oldEnvVars)
[17:29:05.613]                 envs <- base::Sys.getenv()
[17:29:05.613]                 names <- names(envs)
[17:29:05.613]                 common <- intersect(names, old_names)
[17:29:05.613]                 added <- setdiff(names, old_names)
[17:29:05.613]                 removed <- setdiff(old_names, names)
[17:29:05.613]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:05.613]                   envs[common]]
[17:29:05.613]                 NAMES <- toupper(changed)
[17:29:05.613]                 args <- list()
[17:29:05.613]                 for (kk in seq_along(NAMES)) {
[17:29:05.613]                   name <- changed[[kk]]
[17:29:05.613]                   NAME <- NAMES[[kk]]
[17:29:05.613]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.613]                     next
[17:29:05.613]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:05.613]                 }
[17:29:05.613]                 NAMES <- toupper(added)
[17:29:05.613]                 for (kk in seq_along(NAMES)) {
[17:29:05.613]                   name <- added[[kk]]
[17:29:05.613]                   NAME <- NAMES[[kk]]
[17:29:05.613]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.613]                     next
[17:29:05.613]                   args[[name]] <- ""
[17:29:05.613]                 }
[17:29:05.613]                 NAMES <- toupper(removed)
[17:29:05.613]                 for (kk in seq_along(NAMES)) {
[17:29:05.613]                   name <- removed[[kk]]
[17:29:05.613]                   NAME <- NAMES[[kk]]
[17:29:05.613]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.613]                     next
[17:29:05.613]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:05.613]                 }
[17:29:05.613]                 if (length(args) > 0) 
[17:29:05.613]                   base::do.call(base::Sys.setenv, args = args)
[17:29:05.613]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:05.613]             }
[17:29:05.613]             else {
[17:29:05.613]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:05.613]             }
[17:29:05.613]             {
[17:29:05.613]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:05.613]                   0L) {
[17:29:05.613]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:05.613]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:05.613]                   base::options(opts)
[17:29:05.613]                 }
[17:29:05.613]                 {
[17:29:05.613]                   {
[17:29:05.613]                     NULL
[17:29:05.613]                     RNGkind("Mersenne-Twister")
[17:29:05.613]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:05.613]                       inherits = FALSE)
[17:29:05.613]                   }
[17:29:05.613]                   options(future.plan = NULL)
[17:29:05.613]                   if (is.na(NA_character_)) 
[17:29:05.613]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:05.613]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:05.613]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:05.613]                     .init = FALSE)
[17:29:05.613]                 }
[17:29:05.613]             }
[17:29:05.613]         }
[17:29:05.613]     })
[17:29:05.613]     if (TRUE) {
[17:29:05.613]         base::sink(type = "output", split = FALSE)
[17:29:05.613]         if (TRUE) {
[17:29:05.613]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:05.613]         }
[17:29:05.613]         else {
[17:29:05.613]             ...future.result["stdout"] <- base::list(NULL)
[17:29:05.613]         }
[17:29:05.613]         base::close(...future.stdout)
[17:29:05.613]         ...future.stdout <- NULL
[17:29:05.613]     }
[17:29:05.613]     ...future.result$conditions <- ...future.conditions
[17:29:05.613]     ...future.result$finished <- base::Sys.time()
[17:29:05.613]     ...future.result
[17:29:05.613] }
[17:29:05.621] plan(): Setting new future strategy stack:
[17:29:05.621] List of future strategies:
[17:29:05.621] 1. sequential:
[17:29:05.621]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:05.621]    - tweaked: FALSE
[17:29:05.621]    - call: NULL
[17:29:05.622] plan(): nbrOfWorkers() = 1
[17:29:05.625] plan(): Setting new future strategy stack:
[17:29:05.625] List of future strategies:
[17:29:05.625] 1. sequential:
[17:29:05.625]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:05.625]    - tweaked: FALSE
[17:29:05.625]    - call: plan(strategy)
[17:29:05.626] plan(): nbrOfWorkers() = 1
[17:29:05.627] SequentialFuture started (and completed)
[17:29:05.627] - Launch lazy future ... done
[17:29:05.627] run() for 'SequentialFuture' ... done
[17:29:05.629] getGlobalsAndPackages() ...
[17:29:05.629] Searching for globals...
[17:29:05.635] - globals found: [1] '{'
[17:29:05.635] Searching for globals ... DONE
[17:29:05.635] Resolving globals: FALSE
[17:29:05.636] 
[17:29:05.636] 
[17:29:05.637] getGlobalsAndPackages() ... DONE
[17:29:05.637] run() for 'Future' ...
[17:29:05.638] - state: 'created'
[17:29:05.638] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:05.639] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:05.639] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:05.640]   - Field: 'label'
[17:29:05.640]   - Field: 'local'
[17:29:05.640]   - Field: 'owner'
[17:29:05.641]   - Field: 'envir'
[17:29:05.641]   - Field: 'packages'
[17:29:05.641]   - Field: 'gc'
[17:29:05.641]   - Field: 'conditions'
[17:29:05.642]   - Field: 'expr'
[17:29:05.642]   - Field: 'uuid'
[17:29:05.642]   - Field: 'seed'
[17:29:05.643]   - Field: 'version'
[17:29:05.643]   - Field: 'result'
[17:29:05.643]   - Field: 'asynchronous'
[17:29:05.644]   - Field: 'calls'
[17:29:05.644]   - Field: 'globals'
[17:29:05.644]   - Field: 'stdout'
[17:29:05.645]   - Field: 'earlySignal'
[17:29:05.645]   - Field: 'lazy'
[17:29:05.645]   - Field: 'state'
[17:29:05.646] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:05.646] - Launch lazy future ...
[17:29:05.647] Packages needed by the future expression (n = 0): <none>
[17:29:05.647] Packages needed by future strategies (n = 0): <none>
[17:29:05.648] {
[17:29:05.648]     {
[17:29:05.648]         {
[17:29:05.648]             ...future.startTime <- base::Sys.time()
[17:29:05.648]             {
[17:29:05.648]                 {
[17:29:05.648]                   {
[17:29:05.648]                     base::local({
[17:29:05.648]                       has_future <- base::requireNamespace("future", 
[17:29:05.648]                         quietly = TRUE)
[17:29:05.648]                       if (has_future) {
[17:29:05.648]                         ns <- base::getNamespace("future")
[17:29:05.648]                         version <- ns[[".package"]][["version"]]
[17:29:05.648]                         if (is.null(version)) 
[17:29:05.648]                           version <- utils::packageVersion("future")
[17:29:05.648]                       }
[17:29:05.648]                       else {
[17:29:05.648]                         version <- NULL
[17:29:05.648]                       }
[17:29:05.648]                       if (!has_future || version < "1.8.0") {
[17:29:05.648]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:05.648]                           "", base::R.version$version.string), 
[17:29:05.648]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:05.648]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:05.648]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:05.648]                             "release", "version")], collapse = " "), 
[17:29:05.648]                           hostname = base::Sys.info()[["nodename"]])
[17:29:05.648]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:05.648]                           info)
[17:29:05.648]                         info <- base::paste(info, collapse = "; ")
[17:29:05.648]                         if (!has_future) {
[17:29:05.648]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:05.648]                             info)
[17:29:05.648]                         }
[17:29:05.648]                         else {
[17:29:05.648]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:05.648]                             info, version)
[17:29:05.648]                         }
[17:29:05.648]                         base::stop(msg)
[17:29:05.648]                       }
[17:29:05.648]                     })
[17:29:05.648]                   }
[17:29:05.648]                   ...future.strategy.old <- future::plan("list")
[17:29:05.648]                   options(future.plan = NULL)
[17:29:05.648]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:05.648]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:05.648]                 }
[17:29:05.648]                 ...future.workdir <- getwd()
[17:29:05.648]             }
[17:29:05.648]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:05.648]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:05.648]         }
[17:29:05.648]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:05.648]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:05.648]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:05.648]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:05.648]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:05.648]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:05.648]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:05.648]             base::names(...future.oldOptions))
[17:29:05.648]     }
[17:29:05.648]     if (FALSE) {
[17:29:05.648]     }
[17:29:05.648]     else {
[17:29:05.648]         if (TRUE) {
[17:29:05.648]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:05.648]                 open = "w")
[17:29:05.648]         }
[17:29:05.648]         else {
[17:29:05.648]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:05.648]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:05.648]         }
[17:29:05.648]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:05.648]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:05.648]             base::sink(type = "output", split = FALSE)
[17:29:05.648]             base::close(...future.stdout)
[17:29:05.648]         }, add = TRUE)
[17:29:05.648]     }
[17:29:05.648]     ...future.frame <- base::sys.nframe()
[17:29:05.648]     ...future.conditions <- base::list()
[17:29:05.648]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:05.648]     if (FALSE) {
[17:29:05.648]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:05.648]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:05.648]     }
[17:29:05.648]     ...future.result <- base::tryCatch({
[17:29:05.648]         base::withCallingHandlers({
[17:29:05.648]             ...future.value <- base::withVisible(base::local({
[17:29:05.648]                 2
[17:29:05.648]             }))
[17:29:05.648]             future::FutureResult(value = ...future.value$value, 
[17:29:05.648]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:05.648]                   ...future.rng), globalenv = if (FALSE) 
[17:29:05.648]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:05.648]                     ...future.globalenv.names))
[17:29:05.648]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:05.648]         }, condition = base::local({
[17:29:05.648]             c <- base::c
[17:29:05.648]             inherits <- base::inherits
[17:29:05.648]             invokeRestart <- base::invokeRestart
[17:29:05.648]             length <- base::length
[17:29:05.648]             list <- base::list
[17:29:05.648]             seq.int <- base::seq.int
[17:29:05.648]             signalCondition <- base::signalCondition
[17:29:05.648]             sys.calls <- base::sys.calls
[17:29:05.648]             `[[` <- base::`[[`
[17:29:05.648]             `+` <- base::`+`
[17:29:05.648]             `<<-` <- base::`<<-`
[17:29:05.648]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:05.648]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:05.648]                   3L)]
[17:29:05.648]             }
[17:29:05.648]             function(cond) {
[17:29:05.648]                 is_error <- inherits(cond, "error")
[17:29:05.648]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:05.648]                   NULL)
[17:29:05.648]                 if (is_error) {
[17:29:05.648]                   sessionInformation <- function() {
[17:29:05.648]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:05.648]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:05.648]                       search = base::search(), system = base::Sys.info())
[17:29:05.648]                   }
[17:29:05.648]                   ...future.conditions[[length(...future.conditions) + 
[17:29:05.648]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:05.648]                     cond$call), session = sessionInformation(), 
[17:29:05.648]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:05.648]                   signalCondition(cond)
[17:29:05.648]                 }
[17:29:05.648]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:05.648]                 "immediateCondition"))) {
[17:29:05.648]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:05.648]                   ...future.conditions[[length(...future.conditions) + 
[17:29:05.648]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:05.648]                   if (TRUE && !signal) {
[17:29:05.648]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:05.648]                     {
[17:29:05.648]                       inherits <- base::inherits
[17:29:05.648]                       invokeRestart <- base::invokeRestart
[17:29:05.648]                       is.null <- base::is.null
[17:29:05.648]                       muffled <- FALSE
[17:29:05.648]                       if (inherits(cond, "message")) {
[17:29:05.648]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:05.648]                         if (muffled) 
[17:29:05.648]                           invokeRestart("muffleMessage")
[17:29:05.648]                       }
[17:29:05.648]                       else if (inherits(cond, "warning")) {
[17:29:05.648]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:05.648]                         if (muffled) 
[17:29:05.648]                           invokeRestart("muffleWarning")
[17:29:05.648]                       }
[17:29:05.648]                       else if (inherits(cond, "condition")) {
[17:29:05.648]                         if (!is.null(pattern)) {
[17:29:05.648]                           computeRestarts <- base::computeRestarts
[17:29:05.648]                           grepl <- base::grepl
[17:29:05.648]                           restarts <- computeRestarts(cond)
[17:29:05.648]                           for (restart in restarts) {
[17:29:05.648]                             name <- restart$name
[17:29:05.648]                             if (is.null(name)) 
[17:29:05.648]                               next
[17:29:05.648]                             if (!grepl(pattern, name)) 
[17:29:05.648]                               next
[17:29:05.648]                             invokeRestart(restart)
[17:29:05.648]                             muffled <- TRUE
[17:29:05.648]                             break
[17:29:05.648]                           }
[17:29:05.648]                         }
[17:29:05.648]                       }
[17:29:05.648]                       invisible(muffled)
[17:29:05.648]                     }
[17:29:05.648]                     muffleCondition(cond, pattern = "^muffle")
[17:29:05.648]                   }
[17:29:05.648]                 }
[17:29:05.648]                 else {
[17:29:05.648]                   if (TRUE) {
[17:29:05.648]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:05.648]                     {
[17:29:05.648]                       inherits <- base::inherits
[17:29:05.648]                       invokeRestart <- base::invokeRestart
[17:29:05.648]                       is.null <- base::is.null
[17:29:05.648]                       muffled <- FALSE
[17:29:05.648]                       if (inherits(cond, "message")) {
[17:29:05.648]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:05.648]                         if (muffled) 
[17:29:05.648]                           invokeRestart("muffleMessage")
[17:29:05.648]                       }
[17:29:05.648]                       else if (inherits(cond, "warning")) {
[17:29:05.648]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:05.648]                         if (muffled) 
[17:29:05.648]                           invokeRestart("muffleWarning")
[17:29:05.648]                       }
[17:29:05.648]                       else if (inherits(cond, "condition")) {
[17:29:05.648]                         if (!is.null(pattern)) {
[17:29:05.648]                           computeRestarts <- base::computeRestarts
[17:29:05.648]                           grepl <- base::grepl
[17:29:05.648]                           restarts <- computeRestarts(cond)
[17:29:05.648]                           for (restart in restarts) {
[17:29:05.648]                             name <- restart$name
[17:29:05.648]                             if (is.null(name)) 
[17:29:05.648]                               next
[17:29:05.648]                             if (!grepl(pattern, name)) 
[17:29:05.648]                               next
[17:29:05.648]                             invokeRestart(restart)
[17:29:05.648]                             muffled <- TRUE
[17:29:05.648]                             break
[17:29:05.648]                           }
[17:29:05.648]                         }
[17:29:05.648]                       }
[17:29:05.648]                       invisible(muffled)
[17:29:05.648]                     }
[17:29:05.648]                     muffleCondition(cond, pattern = "^muffle")
[17:29:05.648]                   }
[17:29:05.648]                 }
[17:29:05.648]             }
[17:29:05.648]         }))
[17:29:05.648]     }, error = function(ex) {
[17:29:05.648]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:05.648]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:05.648]                 ...future.rng), started = ...future.startTime, 
[17:29:05.648]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:05.648]             version = "1.8"), class = "FutureResult")
[17:29:05.648]     }, finally = {
[17:29:05.648]         if (!identical(...future.workdir, getwd())) 
[17:29:05.648]             setwd(...future.workdir)
[17:29:05.648]         {
[17:29:05.648]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:05.648]                 ...future.oldOptions$nwarnings <- NULL
[17:29:05.648]             }
[17:29:05.648]             base::options(...future.oldOptions)
[17:29:05.648]             if (.Platform$OS.type == "windows") {
[17:29:05.648]                 old_names <- names(...future.oldEnvVars)
[17:29:05.648]                 envs <- base::Sys.getenv()
[17:29:05.648]                 names <- names(envs)
[17:29:05.648]                 common <- intersect(names, old_names)
[17:29:05.648]                 added <- setdiff(names, old_names)
[17:29:05.648]                 removed <- setdiff(old_names, names)
[17:29:05.648]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:05.648]                   envs[common]]
[17:29:05.648]                 NAMES <- toupper(changed)
[17:29:05.648]                 args <- list()
[17:29:05.648]                 for (kk in seq_along(NAMES)) {
[17:29:05.648]                   name <- changed[[kk]]
[17:29:05.648]                   NAME <- NAMES[[kk]]
[17:29:05.648]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.648]                     next
[17:29:05.648]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:05.648]                 }
[17:29:05.648]                 NAMES <- toupper(added)
[17:29:05.648]                 for (kk in seq_along(NAMES)) {
[17:29:05.648]                   name <- added[[kk]]
[17:29:05.648]                   NAME <- NAMES[[kk]]
[17:29:05.648]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.648]                     next
[17:29:05.648]                   args[[name]] <- ""
[17:29:05.648]                 }
[17:29:05.648]                 NAMES <- toupper(removed)
[17:29:05.648]                 for (kk in seq_along(NAMES)) {
[17:29:05.648]                   name <- removed[[kk]]
[17:29:05.648]                   NAME <- NAMES[[kk]]
[17:29:05.648]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.648]                     next
[17:29:05.648]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:05.648]                 }
[17:29:05.648]                 if (length(args) > 0) 
[17:29:05.648]                   base::do.call(base::Sys.setenv, args = args)
[17:29:05.648]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:05.648]             }
[17:29:05.648]             else {
[17:29:05.648]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:05.648]             }
[17:29:05.648]             {
[17:29:05.648]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:05.648]                   0L) {
[17:29:05.648]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:05.648]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:05.648]                   base::options(opts)
[17:29:05.648]                 }
[17:29:05.648]                 {
[17:29:05.648]                   {
[17:29:05.648]                     NULL
[17:29:05.648]                     RNGkind("Mersenne-Twister")
[17:29:05.648]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:05.648]                       inherits = FALSE)
[17:29:05.648]                   }
[17:29:05.648]                   options(future.plan = NULL)
[17:29:05.648]                   if (is.na(NA_character_)) 
[17:29:05.648]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:05.648]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:05.648]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:05.648]                     .init = FALSE)
[17:29:05.648]                 }
[17:29:05.648]             }
[17:29:05.648]         }
[17:29:05.648]     })
[17:29:05.648]     if (TRUE) {
[17:29:05.648]         base::sink(type = "output", split = FALSE)
[17:29:05.648]         if (TRUE) {
[17:29:05.648]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:05.648]         }
[17:29:05.648]         else {
[17:29:05.648]             ...future.result["stdout"] <- base::list(NULL)
[17:29:05.648]         }
[17:29:05.648]         base::close(...future.stdout)
[17:29:05.648]         ...future.stdout <- NULL
[17:29:05.648]     }
[17:29:05.648]     ...future.result$conditions <- ...future.conditions
[17:29:05.648]     ...future.result$finished <- base::Sys.time()
[17:29:05.648]     ...future.result
[17:29:05.648] }
[17:29:05.655] plan(): Setting new future strategy stack:
[17:29:05.655] List of future strategies:
[17:29:05.655] 1. sequential:
[17:29:05.655]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:05.655]    - tweaked: FALSE
[17:29:05.655]    - call: NULL
[17:29:05.657] plan(): nbrOfWorkers() = 1
[17:29:05.659] plan(): Setting new future strategy stack:
[17:29:05.659] List of future strategies:
[17:29:05.659] 1. sequential:
[17:29:05.659]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:05.659]    - tweaked: FALSE
[17:29:05.659]    - call: plan(strategy)
[17:29:05.660] plan(): nbrOfWorkers() = 1
[17:29:05.661] SequentialFuture started (and completed)
[17:29:05.661] - Launch lazy future ... done
[17:29:05.661] run() for 'SequentialFuture' ... done
[17:29:05.663] resolve() on list environment ...
[17:29:05.663]  recursive: 0
[17:29:05.664]  length: 3
[17:29:05.665]  elements: 'a', 'b', 'c'
[17:29:05.665] resolved() for 'SequentialFuture' ...
[17:29:05.666] - state: 'finished'
[17:29:05.666] - run: TRUE
[17:29:05.666] - result: 'FutureResult'
[17:29:05.667] resolved() for 'SequentialFuture' ... done
[17:29:05.667] Future #1
[17:29:05.667]  length: 2 (resolved future 1)
[17:29:05.668] resolved() for 'SequentialFuture' ...
[17:29:05.668] - state: 'finished'
[17:29:05.669] - run: TRUE
[17:29:05.669] - result: 'FutureResult'
[17:29:05.669] resolved() for 'SequentialFuture' ... done
[17:29:05.670] Future #2
[17:29:05.670]  length: 1 (resolved future 2)
[17:29:05.670]  length: 0 (resolved future 3)
[17:29:05.671] resolve() on list environment ... DONE
[17:29:05.672] getGlobalsAndPackages() ...
[17:29:05.672] Searching for globals...
[17:29:05.674] - globals found: [1] '{'
[17:29:05.674] Searching for globals ... DONE
[17:29:05.675] Resolving globals: FALSE
[17:29:05.676] 
[17:29:05.676] 
[17:29:05.676] getGlobalsAndPackages() ... DONE
[17:29:05.677] run() for 'Future' ...
[17:29:05.677] - state: 'created'
[17:29:05.678] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:05.679] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:05.679] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:05.679]   - Field: 'label'
[17:29:05.680]   - Field: 'local'
[17:29:05.680]   - Field: 'owner'
[17:29:05.680]   - Field: 'envir'
[17:29:05.681]   - Field: 'packages'
[17:29:05.681]   - Field: 'gc'
[17:29:05.681]   - Field: 'conditions'
[17:29:05.682]   - Field: 'expr'
[17:29:05.682]   - Field: 'uuid'
[17:29:05.683]   - Field: 'seed'
[17:29:05.683]   - Field: 'version'
[17:29:05.683]   - Field: 'result'
[17:29:05.684]   - Field: 'asynchronous'
[17:29:05.684]   - Field: 'calls'
[17:29:05.684]   - Field: 'globals'
[17:29:05.685]   - Field: 'stdout'
[17:29:05.685]   - Field: 'earlySignal'
[17:29:05.685]   - Field: 'lazy'
[17:29:05.686]   - Field: 'state'
[17:29:05.686] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:05.686] - Launch lazy future ...
[17:29:05.687] Packages needed by the future expression (n = 0): <none>
[17:29:05.687] Packages needed by future strategies (n = 0): <none>
[17:29:05.689] {
[17:29:05.689]     {
[17:29:05.689]         {
[17:29:05.689]             ...future.startTime <- base::Sys.time()
[17:29:05.689]             {
[17:29:05.689]                 {
[17:29:05.689]                   {
[17:29:05.689]                     base::local({
[17:29:05.689]                       has_future <- base::requireNamespace("future", 
[17:29:05.689]                         quietly = TRUE)
[17:29:05.689]                       if (has_future) {
[17:29:05.689]                         ns <- base::getNamespace("future")
[17:29:05.689]                         version <- ns[[".package"]][["version"]]
[17:29:05.689]                         if (is.null(version)) 
[17:29:05.689]                           version <- utils::packageVersion("future")
[17:29:05.689]                       }
[17:29:05.689]                       else {
[17:29:05.689]                         version <- NULL
[17:29:05.689]                       }
[17:29:05.689]                       if (!has_future || version < "1.8.0") {
[17:29:05.689]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:05.689]                           "", base::R.version$version.string), 
[17:29:05.689]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:05.689]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:05.689]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:05.689]                             "release", "version")], collapse = " "), 
[17:29:05.689]                           hostname = base::Sys.info()[["nodename"]])
[17:29:05.689]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:05.689]                           info)
[17:29:05.689]                         info <- base::paste(info, collapse = "; ")
[17:29:05.689]                         if (!has_future) {
[17:29:05.689]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:05.689]                             info)
[17:29:05.689]                         }
[17:29:05.689]                         else {
[17:29:05.689]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:05.689]                             info, version)
[17:29:05.689]                         }
[17:29:05.689]                         base::stop(msg)
[17:29:05.689]                       }
[17:29:05.689]                     })
[17:29:05.689]                   }
[17:29:05.689]                   ...future.strategy.old <- future::plan("list")
[17:29:05.689]                   options(future.plan = NULL)
[17:29:05.689]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:05.689]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:05.689]                 }
[17:29:05.689]                 ...future.workdir <- getwd()
[17:29:05.689]             }
[17:29:05.689]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:05.689]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:05.689]         }
[17:29:05.689]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:05.689]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:05.689]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:05.689]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:05.689]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:05.689]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:05.689]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:05.689]             base::names(...future.oldOptions))
[17:29:05.689]     }
[17:29:05.689]     if (FALSE) {
[17:29:05.689]     }
[17:29:05.689]     else {
[17:29:05.689]         if (TRUE) {
[17:29:05.689]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:05.689]                 open = "w")
[17:29:05.689]         }
[17:29:05.689]         else {
[17:29:05.689]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:05.689]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:05.689]         }
[17:29:05.689]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:05.689]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:05.689]             base::sink(type = "output", split = FALSE)
[17:29:05.689]             base::close(...future.stdout)
[17:29:05.689]         }, add = TRUE)
[17:29:05.689]     }
[17:29:05.689]     ...future.frame <- base::sys.nframe()
[17:29:05.689]     ...future.conditions <- base::list()
[17:29:05.689]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:05.689]     if (FALSE) {
[17:29:05.689]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:05.689]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:05.689]     }
[17:29:05.689]     ...future.result <- base::tryCatch({
[17:29:05.689]         base::withCallingHandlers({
[17:29:05.689]             ...future.value <- base::withVisible(base::local({
[17:29:05.689]                 1
[17:29:05.689]             }))
[17:29:05.689]             future::FutureResult(value = ...future.value$value, 
[17:29:05.689]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:05.689]                   ...future.rng), globalenv = if (FALSE) 
[17:29:05.689]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:05.689]                     ...future.globalenv.names))
[17:29:05.689]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:05.689]         }, condition = base::local({
[17:29:05.689]             c <- base::c
[17:29:05.689]             inherits <- base::inherits
[17:29:05.689]             invokeRestart <- base::invokeRestart
[17:29:05.689]             length <- base::length
[17:29:05.689]             list <- base::list
[17:29:05.689]             seq.int <- base::seq.int
[17:29:05.689]             signalCondition <- base::signalCondition
[17:29:05.689]             sys.calls <- base::sys.calls
[17:29:05.689]             `[[` <- base::`[[`
[17:29:05.689]             `+` <- base::`+`
[17:29:05.689]             `<<-` <- base::`<<-`
[17:29:05.689]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:05.689]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:05.689]                   3L)]
[17:29:05.689]             }
[17:29:05.689]             function(cond) {
[17:29:05.689]                 is_error <- inherits(cond, "error")
[17:29:05.689]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:05.689]                   NULL)
[17:29:05.689]                 if (is_error) {
[17:29:05.689]                   sessionInformation <- function() {
[17:29:05.689]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:05.689]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:05.689]                       search = base::search(), system = base::Sys.info())
[17:29:05.689]                   }
[17:29:05.689]                   ...future.conditions[[length(...future.conditions) + 
[17:29:05.689]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:05.689]                     cond$call), session = sessionInformation(), 
[17:29:05.689]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:05.689]                   signalCondition(cond)
[17:29:05.689]                 }
[17:29:05.689]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:05.689]                 "immediateCondition"))) {
[17:29:05.689]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:05.689]                   ...future.conditions[[length(...future.conditions) + 
[17:29:05.689]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:05.689]                   if (TRUE && !signal) {
[17:29:05.689]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:05.689]                     {
[17:29:05.689]                       inherits <- base::inherits
[17:29:05.689]                       invokeRestart <- base::invokeRestart
[17:29:05.689]                       is.null <- base::is.null
[17:29:05.689]                       muffled <- FALSE
[17:29:05.689]                       if (inherits(cond, "message")) {
[17:29:05.689]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:05.689]                         if (muffled) 
[17:29:05.689]                           invokeRestart("muffleMessage")
[17:29:05.689]                       }
[17:29:05.689]                       else if (inherits(cond, "warning")) {
[17:29:05.689]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:05.689]                         if (muffled) 
[17:29:05.689]                           invokeRestart("muffleWarning")
[17:29:05.689]                       }
[17:29:05.689]                       else if (inherits(cond, "condition")) {
[17:29:05.689]                         if (!is.null(pattern)) {
[17:29:05.689]                           computeRestarts <- base::computeRestarts
[17:29:05.689]                           grepl <- base::grepl
[17:29:05.689]                           restarts <- computeRestarts(cond)
[17:29:05.689]                           for (restart in restarts) {
[17:29:05.689]                             name <- restart$name
[17:29:05.689]                             if (is.null(name)) 
[17:29:05.689]                               next
[17:29:05.689]                             if (!grepl(pattern, name)) 
[17:29:05.689]                               next
[17:29:05.689]                             invokeRestart(restart)
[17:29:05.689]                             muffled <- TRUE
[17:29:05.689]                             break
[17:29:05.689]                           }
[17:29:05.689]                         }
[17:29:05.689]                       }
[17:29:05.689]                       invisible(muffled)
[17:29:05.689]                     }
[17:29:05.689]                     muffleCondition(cond, pattern = "^muffle")
[17:29:05.689]                   }
[17:29:05.689]                 }
[17:29:05.689]                 else {
[17:29:05.689]                   if (TRUE) {
[17:29:05.689]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:05.689]                     {
[17:29:05.689]                       inherits <- base::inherits
[17:29:05.689]                       invokeRestart <- base::invokeRestart
[17:29:05.689]                       is.null <- base::is.null
[17:29:05.689]                       muffled <- FALSE
[17:29:05.689]                       if (inherits(cond, "message")) {
[17:29:05.689]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:05.689]                         if (muffled) 
[17:29:05.689]                           invokeRestart("muffleMessage")
[17:29:05.689]                       }
[17:29:05.689]                       else if (inherits(cond, "warning")) {
[17:29:05.689]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:05.689]                         if (muffled) 
[17:29:05.689]                           invokeRestart("muffleWarning")
[17:29:05.689]                       }
[17:29:05.689]                       else if (inherits(cond, "condition")) {
[17:29:05.689]                         if (!is.null(pattern)) {
[17:29:05.689]                           computeRestarts <- base::computeRestarts
[17:29:05.689]                           grepl <- base::grepl
[17:29:05.689]                           restarts <- computeRestarts(cond)
[17:29:05.689]                           for (restart in restarts) {
[17:29:05.689]                             name <- restart$name
[17:29:05.689]                             if (is.null(name)) 
[17:29:05.689]                               next
[17:29:05.689]                             if (!grepl(pattern, name)) 
[17:29:05.689]                               next
[17:29:05.689]                             invokeRestart(restart)
[17:29:05.689]                             muffled <- TRUE
[17:29:05.689]                             break
[17:29:05.689]                           }
[17:29:05.689]                         }
[17:29:05.689]                       }
[17:29:05.689]                       invisible(muffled)
[17:29:05.689]                     }
[17:29:05.689]                     muffleCondition(cond, pattern = "^muffle")
[17:29:05.689]                   }
[17:29:05.689]                 }
[17:29:05.689]             }
[17:29:05.689]         }))
[17:29:05.689]     }, error = function(ex) {
[17:29:05.689]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:05.689]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:05.689]                 ...future.rng), started = ...future.startTime, 
[17:29:05.689]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:05.689]             version = "1.8"), class = "FutureResult")
[17:29:05.689]     }, finally = {
[17:29:05.689]         if (!identical(...future.workdir, getwd())) 
[17:29:05.689]             setwd(...future.workdir)
[17:29:05.689]         {
[17:29:05.689]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:05.689]                 ...future.oldOptions$nwarnings <- NULL
[17:29:05.689]             }
[17:29:05.689]             base::options(...future.oldOptions)
[17:29:05.689]             if (.Platform$OS.type == "windows") {
[17:29:05.689]                 old_names <- names(...future.oldEnvVars)
[17:29:05.689]                 envs <- base::Sys.getenv()
[17:29:05.689]                 names <- names(envs)
[17:29:05.689]                 common <- intersect(names, old_names)
[17:29:05.689]                 added <- setdiff(names, old_names)
[17:29:05.689]                 removed <- setdiff(old_names, names)
[17:29:05.689]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:05.689]                   envs[common]]
[17:29:05.689]                 NAMES <- toupper(changed)
[17:29:05.689]                 args <- list()
[17:29:05.689]                 for (kk in seq_along(NAMES)) {
[17:29:05.689]                   name <- changed[[kk]]
[17:29:05.689]                   NAME <- NAMES[[kk]]
[17:29:05.689]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.689]                     next
[17:29:05.689]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:05.689]                 }
[17:29:05.689]                 NAMES <- toupper(added)
[17:29:05.689]                 for (kk in seq_along(NAMES)) {
[17:29:05.689]                   name <- added[[kk]]
[17:29:05.689]                   NAME <- NAMES[[kk]]
[17:29:05.689]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.689]                     next
[17:29:05.689]                   args[[name]] <- ""
[17:29:05.689]                 }
[17:29:05.689]                 NAMES <- toupper(removed)
[17:29:05.689]                 for (kk in seq_along(NAMES)) {
[17:29:05.689]                   name <- removed[[kk]]
[17:29:05.689]                   NAME <- NAMES[[kk]]
[17:29:05.689]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.689]                     next
[17:29:05.689]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:05.689]                 }
[17:29:05.689]                 if (length(args) > 0) 
[17:29:05.689]                   base::do.call(base::Sys.setenv, args = args)
[17:29:05.689]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:05.689]             }
[17:29:05.689]             else {
[17:29:05.689]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:05.689]             }
[17:29:05.689]             {
[17:29:05.689]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:05.689]                   0L) {
[17:29:05.689]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:05.689]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:05.689]                   base::options(opts)
[17:29:05.689]                 }
[17:29:05.689]                 {
[17:29:05.689]                   {
[17:29:05.689]                     NULL
[17:29:05.689]                     RNGkind("Mersenne-Twister")
[17:29:05.689]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:05.689]                       inherits = FALSE)
[17:29:05.689]                   }
[17:29:05.689]                   options(future.plan = NULL)
[17:29:05.689]                   if (is.na(NA_character_)) 
[17:29:05.689]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:05.689]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:05.689]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:05.689]                     .init = FALSE)
[17:29:05.689]                 }
[17:29:05.689]             }
[17:29:05.689]         }
[17:29:05.689]     })
[17:29:05.689]     if (TRUE) {
[17:29:05.689]         base::sink(type = "output", split = FALSE)
[17:29:05.689]         if (TRUE) {
[17:29:05.689]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:05.689]         }
[17:29:05.689]         else {
[17:29:05.689]             ...future.result["stdout"] <- base::list(NULL)
[17:29:05.689]         }
[17:29:05.689]         base::close(...future.stdout)
[17:29:05.689]         ...future.stdout <- NULL
[17:29:05.689]     }
[17:29:05.689]     ...future.result$conditions <- ...future.conditions
[17:29:05.689]     ...future.result$finished <- base::Sys.time()
[17:29:05.689]     ...future.result
[17:29:05.689] }
[17:29:05.697] plan(): Setting new future strategy stack:
[17:29:05.697] List of future strategies:
[17:29:05.697] 1. sequential:
[17:29:05.697]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:05.697]    - tweaked: FALSE
[17:29:05.697]    - call: NULL
[17:29:05.698] plan(): nbrOfWorkers() = 1
[17:29:05.701] plan(): Setting new future strategy stack:
[17:29:05.701] List of future strategies:
[17:29:05.701] 1. sequential:
[17:29:05.701]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:05.701]    - tweaked: FALSE
[17:29:05.701]    - call: plan(strategy)
[17:29:05.703] plan(): nbrOfWorkers() = 1
[17:29:05.707] SequentialFuture started (and completed)
[17:29:05.707] - Launch lazy future ... done
[17:29:05.708] run() for 'SequentialFuture' ... done
[17:29:05.709] getGlobalsAndPackages() ...
[17:29:05.709] Searching for globals...
[17:29:05.712] - globals found: [2] '{', 'Sys.sleep'
[17:29:05.713] Searching for globals ... DONE
[17:29:05.713] Resolving globals: FALSE
[17:29:05.714] 
[17:29:05.714] 
[17:29:05.714] getGlobalsAndPackages() ... DONE
[17:29:05.715] run() for 'Future' ...
[17:29:05.715] - state: 'created'
[17:29:05.716] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:05.717] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:05.717] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:05.717]   - Field: 'label'
[17:29:05.718]   - Field: 'local'
[17:29:05.718]   - Field: 'owner'
[17:29:05.718]   - Field: 'envir'
[17:29:05.719]   - Field: 'packages'
[17:29:05.719]   - Field: 'gc'
[17:29:05.720]   - Field: 'conditions'
[17:29:05.720]   - Field: 'expr'
[17:29:05.720]   - Field: 'uuid'
[17:29:05.721]   - Field: 'seed'
[17:29:05.721]   - Field: 'version'
[17:29:05.721]   - Field: 'result'
[17:29:05.722]   - Field: 'asynchronous'
[17:29:05.722]   - Field: 'calls'
[17:29:05.722]   - Field: 'globals'
[17:29:05.723]   - Field: 'stdout'
[17:29:05.723]   - Field: 'earlySignal'
[17:29:05.723]   - Field: 'lazy'
[17:29:05.724]   - Field: 'state'
[17:29:05.724] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:05.724] - Launch lazy future ...
[17:29:05.725] Packages needed by the future expression (n = 0): <none>
[17:29:05.725] Packages needed by future strategies (n = 0): <none>
[17:29:05.726] {
[17:29:05.726]     {
[17:29:05.726]         {
[17:29:05.726]             ...future.startTime <- base::Sys.time()
[17:29:05.726]             {
[17:29:05.726]                 {
[17:29:05.726]                   {
[17:29:05.726]                     base::local({
[17:29:05.726]                       has_future <- base::requireNamespace("future", 
[17:29:05.726]                         quietly = TRUE)
[17:29:05.726]                       if (has_future) {
[17:29:05.726]                         ns <- base::getNamespace("future")
[17:29:05.726]                         version <- ns[[".package"]][["version"]]
[17:29:05.726]                         if (is.null(version)) 
[17:29:05.726]                           version <- utils::packageVersion("future")
[17:29:05.726]                       }
[17:29:05.726]                       else {
[17:29:05.726]                         version <- NULL
[17:29:05.726]                       }
[17:29:05.726]                       if (!has_future || version < "1.8.0") {
[17:29:05.726]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:05.726]                           "", base::R.version$version.string), 
[17:29:05.726]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:05.726]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:05.726]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:05.726]                             "release", "version")], collapse = " "), 
[17:29:05.726]                           hostname = base::Sys.info()[["nodename"]])
[17:29:05.726]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:05.726]                           info)
[17:29:05.726]                         info <- base::paste(info, collapse = "; ")
[17:29:05.726]                         if (!has_future) {
[17:29:05.726]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:05.726]                             info)
[17:29:05.726]                         }
[17:29:05.726]                         else {
[17:29:05.726]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:05.726]                             info, version)
[17:29:05.726]                         }
[17:29:05.726]                         base::stop(msg)
[17:29:05.726]                       }
[17:29:05.726]                     })
[17:29:05.726]                   }
[17:29:05.726]                   ...future.strategy.old <- future::plan("list")
[17:29:05.726]                   options(future.plan = NULL)
[17:29:05.726]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:05.726]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:05.726]                 }
[17:29:05.726]                 ...future.workdir <- getwd()
[17:29:05.726]             }
[17:29:05.726]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:05.726]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:05.726]         }
[17:29:05.726]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:05.726]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:05.726]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:05.726]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:05.726]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:05.726]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:05.726]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:05.726]             base::names(...future.oldOptions))
[17:29:05.726]     }
[17:29:05.726]     if (FALSE) {
[17:29:05.726]     }
[17:29:05.726]     else {
[17:29:05.726]         if (TRUE) {
[17:29:05.726]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:05.726]                 open = "w")
[17:29:05.726]         }
[17:29:05.726]         else {
[17:29:05.726]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:05.726]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:05.726]         }
[17:29:05.726]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:05.726]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:05.726]             base::sink(type = "output", split = FALSE)
[17:29:05.726]             base::close(...future.stdout)
[17:29:05.726]         }, add = TRUE)
[17:29:05.726]     }
[17:29:05.726]     ...future.frame <- base::sys.nframe()
[17:29:05.726]     ...future.conditions <- base::list()
[17:29:05.726]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:05.726]     if (FALSE) {
[17:29:05.726]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:05.726]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:05.726]     }
[17:29:05.726]     ...future.result <- base::tryCatch({
[17:29:05.726]         base::withCallingHandlers({
[17:29:05.726]             ...future.value <- base::withVisible(base::local({
[17:29:05.726]                 Sys.sleep(0.5)
[17:29:05.726]                 2
[17:29:05.726]             }))
[17:29:05.726]             future::FutureResult(value = ...future.value$value, 
[17:29:05.726]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:05.726]                   ...future.rng), globalenv = if (FALSE) 
[17:29:05.726]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:05.726]                     ...future.globalenv.names))
[17:29:05.726]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:05.726]         }, condition = base::local({
[17:29:05.726]             c <- base::c
[17:29:05.726]             inherits <- base::inherits
[17:29:05.726]             invokeRestart <- base::invokeRestart
[17:29:05.726]             length <- base::length
[17:29:05.726]             list <- base::list
[17:29:05.726]             seq.int <- base::seq.int
[17:29:05.726]             signalCondition <- base::signalCondition
[17:29:05.726]             sys.calls <- base::sys.calls
[17:29:05.726]             `[[` <- base::`[[`
[17:29:05.726]             `+` <- base::`+`
[17:29:05.726]             `<<-` <- base::`<<-`
[17:29:05.726]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:05.726]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:05.726]                   3L)]
[17:29:05.726]             }
[17:29:05.726]             function(cond) {
[17:29:05.726]                 is_error <- inherits(cond, "error")
[17:29:05.726]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:05.726]                   NULL)
[17:29:05.726]                 if (is_error) {
[17:29:05.726]                   sessionInformation <- function() {
[17:29:05.726]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:05.726]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:05.726]                       search = base::search(), system = base::Sys.info())
[17:29:05.726]                   }
[17:29:05.726]                   ...future.conditions[[length(...future.conditions) + 
[17:29:05.726]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:05.726]                     cond$call), session = sessionInformation(), 
[17:29:05.726]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:05.726]                   signalCondition(cond)
[17:29:05.726]                 }
[17:29:05.726]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:05.726]                 "immediateCondition"))) {
[17:29:05.726]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:05.726]                   ...future.conditions[[length(...future.conditions) + 
[17:29:05.726]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:05.726]                   if (TRUE && !signal) {
[17:29:05.726]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:05.726]                     {
[17:29:05.726]                       inherits <- base::inherits
[17:29:05.726]                       invokeRestart <- base::invokeRestart
[17:29:05.726]                       is.null <- base::is.null
[17:29:05.726]                       muffled <- FALSE
[17:29:05.726]                       if (inherits(cond, "message")) {
[17:29:05.726]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:05.726]                         if (muffled) 
[17:29:05.726]                           invokeRestart("muffleMessage")
[17:29:05.726]                       }
[17:29:05.726]                       else if (inherits(cond, "warning")) {
[17:29:05.726]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:05.726]                         if (muffled) 
[17:29:05.726]                           invokeRestart("muffleWarning")
[17:29:05.726]                       }
[17:29:05.726]                       else if (inherits(cond, "condition")) {
[17:29:05.726]                         if (!is.null(pattern)) {
[17:29:05.726]                           computeRestarts <- base::computeRestarts
[17:29:05.726]                           grepl <- base::grepl
[17:29:05.726]                           restarts <- computeRestarts(cond)
[17:29:05.726]                           for (restart in restarts) {
[17:29:05.726]                             name <- restart$name
[17:29:05.726]                             if (is.null(name)) 
[17:29:05.726]                               next
[17:29:05.726]                             if (!grepl(pattern, name)) 
[17:29:05.726]                               next
[17:29:05.726]                             invokeRestart(restart)
[17:29:05.726]                             muffled <- TRUE
[17:29:05.726]                             break
[17:29:05.726]                           }
[17:29:05.726]                         }
[17:29:05.726]                       }
[17:29:05.726]                       invisible(muffled)
[17:29:05.726]                     }
[17:29:05.726]                     muffleCondition(cond, pattern = "^muffle")
[17:29:05.726]                   }
[17:29:05.726]                 }
[17:29:05.726]                 else {
[17:29:05.726]                   if (TRUE) {
[17:29:05.726]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:05.726]                     {
[17:29:05.726]                       inherits <- base::inherits
[17:29:05.726]                       invokeRestart <- base::invokeRestart
[17:29:05.726]                       is.null <- base::is.null
[17:29:05.726]                       muffled <- FALSE
[17:29:05.726]                       if (inherits(cond, "message")) {
[17:29:05.726]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:05.726]                         if (muffled) 
[17:29:05.726]                           invokeRestart("muffleMessage")
[17:29:05.726]                       }
[17:29:05.726]                       else if (inherits(cond, "warning")) {
[17:29:05.726]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:05.726]                         if (muffled) 
[17:29:05.726]                           invokeRestart("muffleWarning")
[17:29:05.726]                       }
[17:29:05.726]                       else if (inherits(cond, "condition")) {
[17:29:05.726]                         if (!is.null(pattern)) {
[17:29:05.726]                           computeRestarts <- base::computeRestarts
[17:29:05.726]                           grepl <- base::grepl
[17:29:05.726]                           restarts <- computeRestarts(cond)
[17:29:05.726]                           for (restart in restarts) {
[17:29:05.726]                             name <- restart$name
[17:29:05.726]                             if (is.null(name)) 
[17:29:05.726]                               next
[17:29:05.726]                             if (!grepl(pattern, name)) 
[17:29:05.726]                               next
[17:29:05.726]                             invokeRestart(restart)
[17:29:05.726]                             muffled <- TRUE
[17:29:05.726]                             break
[17:29:05.726]                           }
[17:29:05.726]                         }
[17:29:05.726]                       }
[17:29:05.726]                       invisible(muffled)
[17:29:05.726]                     }
[17:29:05.726]                     muffleCondition(cond, pattern = "^muffle")
[17:29:05.726]                   }
[17:29:05.726]                 }
[17:29:05.726]             }
[17:29:05.726]         }))
[17:29:05.726]     }, error = function(ex) {
[17:29:05.726]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:05.726]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:05.726]                 ...future.rng), started = ...future.startTime, 
[17:29:05.726]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:05.726]             version = "1.8"), class = "FutureResult")
[17:29:05.726]     }, finally = {
[17:29:05.726]         if (!identical(...future.workdir, getwd())) 
[17:29:05.726]             setwd(...future.workdir)
[17:29:05.726]         {
[17:29:05.726]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:05.726]                 ...future.oldOptions$nwarnings <- NULL
[17:29:05.726]             }
[17:29:05.726]             base::options(...future.oldOptions)
[17:29:05.726]             if (.Platform$OS.type == "windows") {
[17:29:05.726]                 old_names <- names(...future.oldEnvVars)
[17:29:05.726]                 envs <- base::Sys.getenv()
[17:29:05.726]                 names <- names(envs)
[17:29:05.726]                 common <- intersect(names, old_names)
[17:29:05.726]                 added <- setdiff(names, old_names)
[17:29:05.726]                 removed <- setdiff(old_names, names)
[17:29:05.726]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:05.726]                   envs[common]]
[17:29:05.726]                 NAMES <- toupper(changed)
[17:29:05.726]                 args <- list()
[17:29:05.726]                 for (kk in seq_along(NAMES)) {
[17:29:05.726]                   name <- changed[[kk]]
[17:29:05.726]                   NAME <- NAMES[[kk]]
[17:29:05.726]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.726]                     next
[17:29:05.726]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:05.726]                 }
[17:29:05.726]                 NAMES <- toupper(added)
[17:29:05.726]                 for (kk in seq_along(NAMES)) {
[17:29:05.726]                   name <- added[[kk]]
[17:29:05.726]                   NAME <- NAMES[[kk]]
[17:29:05.726]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.726]                     next
[17:29:05.726]                   args[[name]] <- ""
[17:29:05.726]                 }
[17:29:05.726]                 NAMES <- toupper(removed)
[17:29:05.726]                 for (kk in seq_along(NAMES)) {
[17:29:05.726]                   name <- removed[[kk]]
[17:29:05.726]                   NAME <- NAMES[[kk]]
[17:29:05.726]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:05.726]                     next
[17:29:05.726]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:05.726]                 }
[17:29:05.726]                 if (length(args) > 0) 
[17:29:05.726]                   base::do.call(base::Sys.setenv, args = args)
[17:29:05.726]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:05.726]             }
[17:29:05.726]             else {
[17:29:05.726]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:05.726]             }
[17:29:05.726]             {
[17:29:05.726]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:05.726]                   0L) {
[17:29:05.726]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:05.726]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:05.726]                   base::options(opts)
[17:29:05.726]                 }
[17:29:05.726]                 {
[17:29:05.726]                   {
[17:29:05.726]                     NULL
[17:29:05.726]                     RNGkind("Mersenne-Twister")
[17:29:05.726]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:05.726]                       inherits = FALSE)
[17:29:05.726]                   }
[17:29:05.726]                   options(future.plan = NULL)
[17:29:05.726]                   if (is.na(NA_character_)) 
[17:29:05.726]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:05.726]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:05.726]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:05.726]                     .init = FALSE)
[17:29:05.726]                 }
[17:29:05.726]             }
[17:29:05.726]         }
[17:29:05.726]     })
[17:29:05.726]     if (TRUE) {
[17:29:05.726]         base::sink(type = "output", split = FALSE)
[17:29:05.726]         if (TRUE) {
[17:29:05.726]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:05.726]         }
[17:29:05.726]         else {
[17:29:05.726]             ...future.result["stdout"] <- base::list(NULL)
[17:29:05.726]         }
[17:29:05.726]         base::close(...future.stdout)
[17:29:05.726]         ...future.stdout <- NULL
[17:29:05.726]     }
[17:29:05.726]     ...future.result$conditions <- ...future.conditions
[17:29:05.726]     ...future.result$finished <- base::Sys.time()
[17:29:05.726]     ...future.result
[17:29:05.726] }
[17:29:05.734] plan(): Setting new future strategy stack:
[17:29:05.734] List of future strategies:
[17:29:05.734] 1. sequential:
[17:29:05.734]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:05.734]    - tweaked: FALSE
[17:29:05.734]    - call: NULL
[17:29:05.735] plan(): nbrOfWorkers() = 1
[17:29:06.238] plan(): Setting new future strategy stack:
[17:29:06.239] List of future strategies:
[17:29:06.239] 1. sequential:
[17:29:06.239]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:06.239]    - tweaked: FALSE
[17:29:06.239]    - call: plan(strategy)
[17:29:06.240] plan(): nbrOfWorkers() = 1
[17:29:06.240] SequentialFuture started (and completed)
[17:29:06.241] - Launch lazy future ... done
[17:29:06.241] run() for 'SequentialFuture' ... done
[17:29:06.242] getGlobalsAndPackages() ...
[17:29:06.242] Searching for globals...
[17:29:06.243] - globals found: [1] '{'
[17:29:06.244] Searching for globals ... DONE
[17:29:06.244] Resolving globals: FALSE
[17:29:06.245] 
[17:29:06.245] 
[17:29:06.245] getGlobalsAndPackages() ... DONE
[17:29:06.246] run() for 'Future' ...
[17:29:06.246] - state: 'created'
[17:29:06.247] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:06.247] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:06.248] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:06.248]   - Field: 'label'
[17:29:06.248]   - Field: 'local'
[17:29:06.248]   - Field: 'owner'
[17:29:06.249]   - Field: 'envir'
[17:29:06.249]   - Field: 'packages'
[17:29:06.249]   - Field: 'gc'
[17:29:06.250]   - Field: 'conditions'
[17:29:06.250]   - Field: 'expr'
[17:29:06.250]   - Field: 'uuid'
[17:29:06.250]   - Field: 'seed'
[17:29:06.251]   - Field: 'version'
[17:29:06.251]   - Field: 'result'
[17:29:06.251]   - Field: 'asynchronous'
[17:29:06.251]   - Field: 'calls'
[17:29:06.252]   - Field: 'globals'
[17:29:06.252]   - Field: 'stdout'
[17:29:06.252]   - Field: 'earlySignal'
[17:29:06.253]   - Field: 'lazy'
[17:29:06.253]   - Field: 'state'
[17:29:06.253] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:06.253] - Launch lazy future ...
[17:29:06.254] Packages needed by the future expression (n = 0): <none>
[17:29:06.254] Packages needed by future strategies (n = 0): <none>
[17:29:06.255] {
[17:29:06.255]     {
[17:29:06.255]         {
[17:29:06.255]             ...future.startTime <- base::Sys.time()
[17:29:06.255]             {
[17:29:06.255]                 {
[17:29:06.255]                   {
[17:29:06.255]                     base::local({
[17:29:06.255]                       has_future <- base::requireNamespace("future", 
[17:29:06.255]                         quietly = TRUE)
[17:29:06.255]                       if (has_future) {
[17:29:06.255]                         ns <- base::getNamespace("future")
[17:29:06.255]                         version <- ns[[".package"]][["version"]]
[17:29:06.255]                         if (is.null(version)) 
[17:29:06.255]                           version <- utils::packageVersion("future")
[17:29:06.255]                       }
[17:29:06.255]                       else {
[17:29:06.255]                         version <- NULL
[17:29:06.255]                       }
[17:29:06.255]                       if (!has_future || version < "1.8.0") {
[17:29:06.255]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:06.255]                           "", base::R.version$version.string), 
[17:29:06.255]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:06.255]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:06.255]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:06.255]                             "release", "version")], collapse = " "), 
[17:29:06.255]                           hostname = base::Sys.info()[["nodename"]])
[17:29:06.255]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:06.255]                           info)
[17:29:06.255]                         info <- base::paste(info, collapse = "; ")
[17:29:06.255]                         if (!has_future) {
[17:29:06.255]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:06.255]                             info)
[17:29:06.255]                         }
[17:29:06.255]                         else {
[17:29:06.255]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:06.255]                             info, version)
[17:29:06.255]                         }
[17:29:06.255]                         base::stop(msg)
[17:29:06.255]                       }
[17:29:06.255]                     })
[17:29:06.255]                   }
[17:29:06.255]                   ...future.strategy.old <- future::plan("list")
[17:29:06.255]                   options(future.plan = NULL)
[17:29:06.255]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:06.255]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:06.255]                 }
[17:29:06.255]                 ...future.workdir <- getwd()
[17:29:06.255]             }
[17:29:06.255]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:06.255]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:06.255]         }
[17:29:06.255]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:06.255]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:06.255]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:06.255]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:06.255]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:06.255]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:06.255]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:06.255]             base::names(...future.oldOptions))
[17:29:06.255]     }
[17:29:06.255]     if (FALSE) {
[17:29:06.255]     }
[17:29:06.255]     else {
[17:29:06.255]         if (TRUE) {
[17:29:06.255]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:06.255]                 open = "w")
[17:29:06.255]         }
[17:29:06.255]         else {
[17:29:06.255]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:06.255]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:06.255]         }
[17:29:06.255]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:06.255]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:06.255]             base::sink(type = "output", split = FALSE)
[17:29:06.255]             base::close(...future.stdout)
[17:29:06.255]         }, add = TRUE)
[17:29:06.255]     }
[17:29:06.255]     ...future.frame <- base::sys.nframe()
[17:29:06.255]     ...future.conditions <- base::list()
[17:29:06.255]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:06.255]     if (FALSE) {
[17:29:06.255]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:06.255]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:06.255]     }
[17:29:06.255]     ...future.result <- base::tryCatch({
[17:29:06.255]         base::withCallingHandlers({
[17:29:06.255]             ...future.value <- base::withVisible(base::local({
[17:29:06.255]                 3
[17:29:06.255]             }))
[17:29:06.255]             future::FutureResult(value = ...future.value$value, 
[17:29:06.255]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:06.255]                   ...future.rng), globalenv = if (FALSE) 
[17:29:06.255]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:06.255]                     ...future.globalenv.names))
[17:29:06.255]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:06.255]         }, condition = base::local({
[17:29:06.255]             c <- base::c
[17:29:06.255]             inherits <- base::inherits
[17:29:06.255]             invokeRestart <- base::invokeRestart
[17:29:06.255]             length <- base::length
[17:29:06.255]             list <- base::list
[17:29:06.255]             seq.int <- base::seq.int
[17:29:06.255]             signalCondition <- base::signalCondition
[17:29:06.255]             sys.calls <- base::sys.calls
[17:29:06.255]             `[[` <- base::`[[`
[17:29:06.255]             `+` <- base::`+`
[17:29:06.255]             `<<-` <- base::`<<-`
[17:29:06.255]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:06.255]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:06.255]                   3L)]
[17:29:06.255]             }
[17:29:06.255]             function(cond) {
[17:29:06.255]                 is_error <- inherits(cond, "error")
[17:29:06.255]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:06.255]                   NULL)
[17:29:06.255]                 if (is_error) {
[17:29:06.255]                   sessionInformation <- function() {
[17:29:06.255]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:06.255]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:06.255]                       search = base::search(), system = base::Sys.info())
[17:29:06.255]                   }
[17:29:06.255]                   ...future.conditions[[length(...future.conditions) + 
[17:29:06.255]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:06.255]                     cond$call), session = sessionInformation(), 
[17:29:06.255]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:06.255]                   signalCondition(cond)
[17:29:06.255]                 }
[17:29:06.255]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:06.255]                 "immediateCondition"))) {
[17:29:06.255]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:06.255]                   ...future.conditions[[length(...future.conditions) + 
[17:29:06.255]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:06.255]                   if (TRUE && !signal) {
[17:29:06.255]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:06.255]                     {
[17:29:06.255]                       inherits <- base::inherits
[17:29:06.255]                       invokeRestart <- base::invokeRestart
[17:29:06.255]                       is.null <- base::is.null
[17:29:06.255]                       muffled <- FALSE
[17:29:06.255]                       if (inherits(cond, "message")) {
[17:29:06.255]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:06.255]                         if (muffled) 
[17:29:06.255]                           invokeRestart("muffleMessage")
[17:29:06.255]                       }
[17:29:06.255]                       else if (inherits(cond, "warning")) {
[17:29:06.255]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:06.255]                         if (muffled) 
[17:29:06.255]                           invokeRestart("muffleWarning")
[17:29:06.255]                       }
[17:29:06.255]                       else if (inherits(cond, "condition")) {
[17:29:06.255]                         if (!is.null(pattern)) {
[17:29:06.255]                           computeRestarts <- base::computeRestarts
[17:29:06.255]                           grepl <- base::grepl
[17:29:06.255]                           restarts <- computeRestarts(cond)
[17:29:06.255]                           for (restart in restarts) {
[17:29:06.255]                             name <- restart$name
[17:29:06.255]                             if (is.null(name)) 
[17:29:06.255]                               next
[17:29:06.255]                             if (!grepl(pattern, name)) 
[17:29:06.255]                               next
[17:29:06.255]                             invokeRestart(restart)
[17:29:06.255]                             muffled <- TRUE
[17:29:06.255]                             break
[17:29:06.255]                           }
[17:29:06.255]                         }
[17:29:06.255]                       }
[17:29:06.255]                       invisible(muffled)
[17:29:06.255]                     }
[17:29:06.255]                     muffleCondition(cond, pattern = "^muffle")
[17:29:06.255]                   }
[17:29:06.255]                 }
[17:29:06.255]                 else {
[17:29:06.255]                   if (TRUE) {
[17:29:06.255]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:06.255]                     {
[17:29:06.255]                       inherits <- base::inherits
[17:29:06.255]                       invokeRestart <- base::invokeRestart
[17:29:06.255]                       is.null <- base::is.null
[17:29:06.255]                       muffled <- FALSE
[17:29:06.255]                       if (inherits(cond, "message")) {
[17:29:06.255]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:06.255]                         if (muffled) 
[17:29:06.255]                           invokeRestart("muffleMessage")
[17:29:06.255]                       }
[17:29:06.255]                       else if (inherits(cond, "warning")) {
[17:29:06.255]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:06.255]                         if (muffled) 
[17:29:06.255]                           invokeRestart("muffleWarning")
[17:29:06.255]                       }
[17:29:06.255]                       else if (inherits(cond, "condition")) {
[17:29:06.255]                         if (!is.null(pattern)) {
[17:29:06.255]                           computeRestarts <- base::computeRestarts
[17:29:06.255]                           grepl <- base::grepl
[17:29:06.255]                           restarts <- computeRestarts(cond)
[17:29:06.255]                           for (restart in restarts) {
[17:29:06.255]                             name <- restart$name
[17:29:06.255]                             if (is.null(name)) 
[17:29:06.255]                               next
[17:29:06.255]                             if (!grepl(pattern, name)) 
[17:29:06.255]                               next
[17:29:06.255]                             invokeRestart(restart)
[17:29:06.255]                             muffled <- TRUE
[17:29:06.255]                             break
[17:29:06.255]                           }
[17:29:06.255]                         }
[17:29:06.255]                       }
[17:29:06.255]                       invisible(muffled)
[17:29:06.255]                     }
[17:29:06.255]                     muffleCondition(cond, pattern = "^muffle")
[17:29:06.255]                   }
[17:29:06.255]                 }
[17:29:06.255]             }
[17:29:06.255]         }))
[17:29:06.255]     }, error = function(ex) {
[17:29:06.255]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:06.255]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:06.255]                 ...future.rng), started = ...future.startTime, 
[17:29:06.255]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:06.255]             version = "1.8"), class = "FutureResult")
[17:29:06.255]     }, finally = {
[17:29:06.255]         if (!identical(...future.workdir, getwd())) 
[17:29:06.255]             setwd(...future.workdir)
[17:29:06.255]         {
[17:29:06.255]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:06.255]                 ...future.oldOptions$nwarnings <- NULL
[17:29:06.255]             }
[17:29:06.255]             base::options(...future.oldOptions)
[17:29:06.255]             if (.Platform$OS.type == "windows") {
[17:29:06.255]                 old_names <- names(...future.oldEnvVars)
[17:29:06.255]                 envs <- base::Sys.getenv()
[17:29:06.255]                 names <- names(envs)
[17:29:06.255]                 common <- intersect(names, old_names)
[17:29:06.255]                 added <- setdiff(names, old_names)
[17:29:06.255]                 removed <- setdiff(old_names, names)
[17:29:06.255]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:06.255]                   envs[common]]
[17:29:06.255]                 NAMES <- toupper(changed)
[17:29:06.255]                 args <- list()
[17:29:06.255]                 for (kk in seq_along(NAMES)) {
[17:29:06.255]                   name <- changed[[kk]]
[17:29:06.255]                   NAME <- NAMES[[kk]]
[17:29:06.255]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:06.255]                     next
[17:29:06.255]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:06.255]                 }
[17:29:06.255]                 NAMES <- toupper(added)
[17:29:06.255]                 for (kk in seq_along(NAMES)) {
[17:29:06.255]                   name <- added[[kk]]
[17:29:06.255]                   NAME <- NAMES[[kk]]
[17:29:06.255]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:06.255]                     next
[17:29:06.255]                   args[[name]] <- ""
[17:29:06.255]                 }
[17:29:06.255]                 NAMES <- toupper(removed)
[17:29:06.255]                 for (kk in seq_along(NAMES)) {
[17:29:06.255]                   name <- removed[[kk]]
[17:29:06.255]                   NAME <- NAMES[[kk]]
[17:29:06.255]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:06.255]                     next
[17:29:06.255]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:06.255]                 }
[17:29:06.255]                 if (length(args) > 0) 
[17:29:06.255]                   base::do.call(base::Sys.setenv, args = args)
[17:29:06.255]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:06.255]             }
[17:29:06.255]             else {
[17:29:06.255]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:06.255]             }
[17:29:06.255]             {
[17:29:06.255]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:06.255]                   0L) {
[17:29:06.255]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:06.255]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:06.255]                   base::options(opts)
[17:29:06.255]                 }
[17:29:06.255]                 {
[17:29:06.255]                   {
[17:29:06.255]                     NULL
[17:29:06.255]                     RNGkind("Mersenne-Twister")
[17:29:06.255]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:29:06.255]                       inherits = FALSE)
[17:29:06.255]                   }
[17:29:06.255]                   options(future.plan = NULL)
[17:29:06.255]                   if (is.na(NA_character_)) 
[17:29:06.255]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:06.255]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:06.255]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:06.255]                     .init = FALSE)
[17:29:06.255]                 }
[17:29:06.255]             }
[17:29:06.255]         }
[17:29:06.255]     })
[17:29:06.255]     if (TRUE) {
[17:29:06.255]         base::sink(type = "output", split = FALSE)
[17:29:06.255]         if (TRUE) {
[17:29:06.255]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:06.255]         }
[17:29:06.255]         else {
[17:29:06.255]             ...future.result["stdout"] <- base::list(NULL)
[17:29:06.255]         }
[17:29:06.255]         base::close(...future.stdout)
[17:29:06.255]         ...future.stdout <- NULL
[17:29:06.255]     }
[17:29:06.255]     ...future.result$conditions <- ...future.conditions
[17:29:06.255]     ...future.result$finished <- base::Sys.time()
[17:29:06.255]     ...future.result
[17:29:06.255] }
[17:29:06.262] plan(): Setting new future strategy stack:
[17:29:06.262] List of future strategies:
[17:29:06.262] 1. sequential:
[17:29:06.262]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:06.262]    - tweaked: FALSE
[17:29:06.262]    - call: NULL
[17:29:06.263] plan(): nbrOfWorkers() = 1
[17:29:06.265] plan(): Setting new future strategy stack:
[17:29:06.265] List of future strategies:
[17:29:06.265] 1. sequential:
[17:29:06.265]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:06.265]    - tweaked: FALSE
[17:29:06.265]    - call: plan(strategy)
[17:29:06.266] plan(): nbrOfWorkers() = 1
[17:29:06.267] SequentialFuture started (and completed)
[17:29:06.267] - Launch lazy future ... done
[17:29:06.267] run() for 'SequentialFuture' ... done
[17:29:06.269] resolve() on list environment ...
[17:29:06.269]  recursive: 0
[17:29:06.273]  length: 4
[17:29:06.273]  elements: 'a', 'b', 'c', 'd'
[17:29:06.274] resolved() for 'SequentialFuture' ...
[17:29:06.274] - state: 'finished'
[17:29:06.274] - run: TRUE
[17:29:06.275] - result: 'FutureResult'
[17:29:06.275] resolved() for 'SequentialFuture' ... done
[17:29:06.275] Future #1
[17:29:06.276]  length: 3 (resolved future 1)
[17:29:06.276] resolved() for 'SequentialFuture' ...
[17:29:06.276] - state: 'finished'
[17:29:06.276] - run: TRUE
[17:29:06.277] - result: 'FutureResult'
[17:29:06.277] resolved() for 'SequentialFuture' ... done
[17:29:06.277] Future #2
[17:29:06.278]  length: 2 (resolved future 2)
[17:29:06.278] resolved() for 'SequentialFuture' ...
[17:29:06.278] - state: 'finished'
[17:29:06.278] - run: TRUE
[17:29:06.279] - result: 'FutureResult'
[17:29:06.279] resolved() for 'SequentialFuture' ... done
[17:29:06.279] Future #3
[17:29:06.279]  length: 1 (resolved future 3)
[17:29:06.280]  length: 0 (resolved future 4)
[17:29:06.280] resolve() on list environment ... DONE
[17:29:06.281] resolved() for 'SequentialFuture' ...
[17:29:06.281] - state: 'finished'
[17:29:06.281] - run: TRUE
[17:29:06.282] - result: 'FutureResult'
[17:29:06.282] resolved() for 'SequentialFuture' ... done
[17:29:06.282] resolve() on list environment ...
[17:29:06.282]  recursive: 0
[17:29:06.284]  length: 4
[17:29:06.284]  elements: 'a', 'b', 'c', 'd'
[17:29:06.284] resolved() for 'SequentialFuture' ...
[17:29:06.284] - state: 'finished'
[17:29:06.285] - run: TRUE
[17:29:06.285] - result: 'FutureResult'
[17:29:06.285] resolved() for 'SequentialFuture' ... done
[17:29:06.286] Future #1
[17:29:06.286]  length: 3 (resolved future 1)
[17:29:06.286] resolved() for 'SequentialFuture' ...
[17:29:06.287] - state: 'finished'
[17:29:06.287] - run: TRUE
[17:29:06.287] - result: 'FutureResult'
[17:29:06.287] resolved() for 'SequentialFuture' ... done
[17:29:06.288] Future #2
[17:29:06.288]  length: 2 (resolved future 2)
[17:29:06.288] resolved() for 'SequentialFuture' ...
[17:29:06.288] - state: 'finished'
[17:29:06.288] - run: TRUE
[17:29:06.289] - result: 'FutureResult'
[17:29:06.289] resolved() for 'SequentialFuture' ... done
[17:29:06.289] Future #3
[17:29:06.289]  length: 1 (resolved future 3)
[17:29:06.289]  length: 0 (resolved future 4)
[17:29:06.290] resolve() on list environment ... DONE
[17:29:06.290] resolve() on list environment ...
[17:29:06.290]  recursive: 0
[17:29:06.291]  length: 4
[17:29:06.291]  elements: 'a', 'b', 'c', 'd'
[17:29:06.292] resolved() for 'SequentialFuture' ...
[17:29:06.292] - state: 'finished'
[17:29:06.292] - run: TRUE
[17:29:06.292] - result: 'FutureResult'
[17:29:06.292] resolved() for 'SequentialFuture' ... done
[17:29:06.293] Future #1
[17:29:06.293]  length: 3 (resolved future 1)
[17:29:06.293] resolved() for 'SequentialFuture' ...
[17:29:06.293] - state: 'finished'
[17:29:06.293] - run: TRUE
[17:29:06.294] - result: 'FutureResult'
[17:29:06.294] resolved() for 'SequentialFuture' ... done
[17:29:06.294] Future #2
[17:29:06.294]  length: 2 (resolved future 2)
[17:29:06.294] resolved() for 'SequentialFuture' ...
[17:29:06.294] - state: 'finished'
[17:29:06.295] - run: TRUE
[17:29:06.295] - result: 'FutureResult'
[17:29:06.295] resolved() for 'SequentialFuture' ... done
[17:29:06.295] Future #3
[17:29:06.295]  length: 1 (resolved future 3)
[17:29:06.296]  length: 0 (resolved future 4)
[17:29:06.296] resolve() on list environment ... DONE
[17:29:06.296] resolve() on list environment ...
[17:29:06.296]  recursive: 0
[17:29:06.297]  length: 4
[17:29:06.297]  elements: 'a', 'b', 'c', 'd'
[17:29:06.298] resolved() for 'SequentialFuture' ...
[17:29:06.298] - state: 'finished'
[17:29:06.298] - run: TRUE
[17:29:06.298] - result: 'FutureResult'
[17:29:06.298] resolved() for 'SequentialFuture' ... done
[17:29:06.299] Future #1
[17:29:06.299]  length: 3 (resolved future 1)
[17:29:06.299] resolved() for 'SequentialFuture' ...
[17:29:06.299] - state: 'finished'
[17:29:06.299] - run: TRUE
[17:29:06.300] - result: 'FutureResult'
[17:29:06.300] resolved() for 'SequentialFuture' ... done
[17:29:06.300] Future #2
[17:29:06.301]  length: 2 (resolved future 2)
[17:29:06.301] resolved() for 'SequentialFuture' ...
[17:29:06.301] - state: 'finished'
[17:29:06.302] - run: TRUE
[17:29:06.302] - result: 'FutureResult'
[17:29:06.302] resolved() for 'SequentialFuture' ... done
[17:29:06.303] Future #3
[17:29:06.303]  length: 1 (resolved future 3)
[17:29:06.303]  length: 0 (resolved future 4)
[17:29:06.304] resolve() on list environment ... DONE
[17:29:06.305] resolve() on list environment ...
[17:29:06.305]  recursive: 0
[17:29:06.307]  length: 4
[17:29:06.307]  elements: 'a', 'b', 'c', 'd'
[17:29:06.307] resolved() for 'SequentialFuture' ...
[17:29:06.308] - state: 'finished'
[17:29:06.308] - run: TRUE
[17:29:06.308] - result: 'FutureResult'
[17:29:06.309] resolved() for 'SequentialFuture' ... done
[17:29:06.309] Future #1
[17:29:06.312]  length: 3 (resolved future 1)
[17:29:06.312] resolved() for 'SequentialFuture' ...
[17:29:06.312] - state: 'finished'
[17:29:06.313] - run: TRUE
[17:29:06.313] - result: 'FutureResult'
[17:29:06.313] resolved() for 'SequentialFuture' ... done
[17:29:06.314] Future #2
[17:29:06.314]  length: 2 (resolved future 2)
[17:29:06.315] resolved() for 'SequentialFuture' ...
[17:29:06.315] - state: 'finished'
[17:29:06.315] - run: TRUE
[17:29:06.316] - result: 'FutureResult'
[17:29:06.316] resolved() for 'SequentialFuture' ... done
[17:29:06.316] Future #3
[17:29:06.317]  length: 1 (resolved future 3)
[17:29:06.317]  length: 0 (resolved future 4)
[17:29:06.318] resolve() on list environment ... DONE
[17:29:06.320] resolve() on list environment ...
[17:29:06.320]  recursive: 99
[17:29:06.322]  length: 4
[17:29:06.322]  elements: 'a', 'b', 'c', 'd'
[17:29:06.323] resolved() for 'SequentialFuture' ...
[17:29:06.323] - state: 'finished'
[17:29:06.323] - run: TRUE
[17:29:06.324] - result: 'FutureResult'
[17:29:06.324] resolved() for 'SequentialFuture' ... done
[17:29:06.325] Future #1
[17:29:06.325] resolved() for 'SequentialFuture' ...
[17:29:06.326] - state: 'finished'
[17:29:06.326] - run: TRUE
[17:29:06.326] - result: 'FutureResult'
[17:29:06.327] resolved() for 'SequentialFuture' ... done
[17:29:06.327] A SequentialFuture was resolved
[17:29:06.328]  length: 3 (resolved future 1)
[17:29:06.328] resolved() for 'SequentialFuture' ...
[17:29:06.328] - state: 'finished'
[17:29:06.329] - run: TRUE
[17:29:06.329] - result: 'FutureResult'
[17:29:06.330] resolved() for 'SequentialFuture' ... done
[17:29:06.330] Future #2
[17:29:06.331] resolved() for 'SequentialFuture' ...
[17:29:06.331] - state: 'finished'
[17:29:06.331] - run: TRUE
[17:29:06.332] - result: 'FutureResult'
[17:29:06.332] resolved() for 'SequentialFuture' ... done
[17:29:06.333] A SequentialFuture was resolved
[17:29:06.333]  length: 2 (resolved future 2)
[17:29:06.334] resolved() for 'SequentialFuture' ...
[17:29:06.334] - state: 'finished'
[17:29:06.335] - run: TRUE
[17:29:06.335] - result: 'FutureResult'
[17:29:06.335] resolved() for 'SequentialFuture' ... done
[17:29:06.336] Future #3
[17:29:06.336] resolved() for 'SequentialFuture' ...
[17:29:06.337] - state: 'finished'
[17:29:06.337] - run: TRUE
[17:29:06.338] - result: 'FutureResult'
[17:29:06.338] resolved() for 'SequentialFuture' ... done
[17:29:06.339] A SequentialFuture was resolved
[17:29:06.339]  length: 1 (resolved future 3)
[17:29:06.339]  length: 0 (resolved future 4)
[17:29:06.340] resolve() on list environment ... DONE
*** resolve() for list environments ... DONE
- plan('sequential') ...
- plan('multisession') ...
[17:29:06.341] plan(): Setting new future strategy stack:
[17:29:06.342] List of future strategies:
[17:29:06.342] 1. multisession:
[17:29:06.342]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:29:06.342]    - tweaked: FALSE
[17:29:06.342]    - call: plan(strategy)
[17:29:06.343] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[17:29:06.344] multisession:
[17:29:06.344] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:29:06.344] - tweaked: FALSE
[17:29:06.344] - call: plan(strategy)
[17:29:06.351] getGlobalsAndPackages() ...
[17:29:06.352] Not searching for globals
[17:29:06.352] - globals: [0] <none>
[17:29:06.352] getGlobalsAndPackages() ... DONE
[17:29:06.353] [local output] makeClusterPSOCK() ...
[17:29:06.408] [local output] Workers: [n = 2] 'localhost', 'localhost'
[17:29:06.416] [local output] Base port: 23237
[17:29:06.416] [local output] Getting setup options for 2 cluster nodes ...
[17:29:06.416] [local output]  - Node #1 of 2 ...
[17:29:06.417] [local output] localMachine=TRUE => revtunnel=FALSE

[17:29:06.419] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpqSJKo7/worker.rank=1.parallelly.parent=128804.1f7243051619b.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/RtmpqSJKo7/worker.rank=1.parallelly.parent=128804.1f7243051619b.pid\")"'
[17:29:06.753] - Possible to infer worker's PID: TRUE
[17:29:06.755] [local output] Rscript port: 23237

[17:29:06.755] [local output]  - Node #2 of 2 ...
[17:29:06.756] [local output] localMachine=TRUE => revtunnel=FALSE

[17:29:06.758] [local output] Rscript port: 23237

[17:29:06.759] [local output] Getting setup options for 2 cluster nodes ... done
[17:29:06.760] [local output]  - Parallel setup requested for some PSOCK nodes
[17:29:06.761] [local output] Setting up PSOCK nodes in parallel
[17:29:06.761] List of 36
[17:29:06.761]  $ worker          : chr "localhost"
[17:29:06.761]   ..- attr(*, "localhost")= logi TRUE
[17:29:06.761]  $ master          : chr "localhost"
[17:29:06.761]  $ port            : int 23237
[17:29:06.761]  $ connectTimeout  : num 120
[17:29:06.761]  $ timeout         : num 120
[17:29:06.761]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[17:29:06.761]  $ homogeneous     : logi TRUE
[17:29:06.761]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=resolve.R:128804:CRANWIN3:CRAN\""| __truncated__
[17:29:06.761]  $ rscript_envs    : NULL
[17:29:06.761]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda" "D:/RCompile/recent/R/library"
[17:29:06.761]  $ rscript_startup : NULL
[17:29:06.761]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[17:29:06.761]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:29:06.761]  $ methods         : logi TRUE
[17:29:06.761]  $ socketOptions   : chr "no-delay"
[17:29:06.761]  $ useXDR          : logi FALSE
[17:29:06.761]  $ outfile         : chr "/dev/null"
[17:29:06.761]  $ renice          : int NA
[17:29:06.761]  $ rshcmd          : NULL
[17:29:06.761]  $ user            : chr(0) 
[17:29:06.761]  $ revtunnel       : logi FALSE
[17:29:06.761]  $ rshlogfile      : NULL
[17:29:06.761]  $ rshopts         : chr(0) 
[17:29:06.761]  $ rank            : int 1
[17:29:06.761]  $ manual          : logi FALSE
[17:29:06.761]  $ dryrun          : logi FALSE
[17:29:06.761]  $ quiet           : logi FALSE
[17:29:06.761]  $ setup_strategy  : chr "parallel"
[17:29:06.761]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:29:06.761]  $ pidfile         : chr "D:/temp/RtmpqSJKo7/worker.rank=1.parallelly.parent=128804.1f7243051619b.pid"
[17:29:06.761]  $ rshcmd_label    : NULL
[17:29:06.761]  $ rsh_call        : NULL
[17:29:06.761]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:29:06.761]  $ localMachine    : logi TRUE
[17:29:06.761]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[17:29:06.761]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[17:29:06.761]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[17:29:06.761]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[17:29:06.761]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[17:29:06.761]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[17:29:06.761]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[17:29:06.761]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[17:29:06.761]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[17:29:06.761]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[17:29:06.761]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[17:29:06.761]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[17:29:06.761]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[17:29:06.761]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[17:29:06.761]  $ arguments       :List of 28
[17:29:06.761]   ..$ worker          : chr "localhost"
[17:29:06.761]   ..$ master          : NULL
[17:29:06.761]   ..$ port            : int 23237
[17:29:06.761]   ..$ connectTimeout  : num 120
[17:29:06.761]   ..$ timeout         : num 120
[17:29:06.761]   ..$ rscript         : NULL
[17:29:06.761]   ..$ homogeneous     : NULL
[17:29:06.761]   ..$ rscript_args    : NULL
[17:29:06.761]   ..$ rscript_envs    : NULL
[17:29:06.761]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda" "D:/RCompile/recent/R/library"
[17:29:06.761]   ..$ rscript_startup : NULL
[17:29:06.761]   ..$ rscript_sh      : chr "auto"
[17:29:06.761]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:29:06.761]   ..$ methods         : logi TRUE
[17:29:06.761]   ..$ socketOptions   : chr "no-delay"
[17:29:06.761]   ..$ useXDR          : logi FALSE
[17:29:06.761]   ..$ outfile         : chr "/dev/null"
[17:29:06.761]   ..$ renice          : int NA
[17:29:06.761]   ..$ rshcmd          : NULL
[17:29:06.761]   ..$ user            : NULL
[17:29:06.761]   ..$ revtunnel       : logi NA
[17:29:06.761]   ..$ rshlogfile      : NULL
[17:29:06.761]   ..$ rshopts         : NULL
[17:29:06.761]   ..$ rank            : int 1
[17:29:06.761]   ..$ manual          : logi FALSE
[17:29:06.761]   ..$ dryrun          : logi FALSE
[17:29:06.761]   ..$ quiet           : logi FALSE
[17:29:06.761]   ..$ setup_strategy  : chr "parallel"
[17:29:06.761]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[17:29:06.796] [local output] System call to launch all workers:
[17:29:06.796] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=resolve.R:128804:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpqSJKo7/worker.rank=1.parallelly.parent=128804.1f7243051619b.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=23237 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[17:29:06.797] [local output] Starting PSOCK main server
[17:29:06.805] [local output] Workers launched
[17:29:06.805] [local output] Waiting for workers to connect back
[17:29:06.805]  - [local output] 0 workers out of 2 ready
[17:29:07.066]  - [local output] 0 workers out of 2 ready
[17:29:07.067]  - [local output] 1 workers out of 2 ready
[17:29:07.106]  - [local output] 1 workers out of 2 ready
[17:29:07.107]  - [local output] 2 workers out of 2 ready
[17:29:07.107] [local output] Launching of 2 workers completed
[17:29:07.108] [local output] Number of nodes in cluster: 2
[17:29:07.108] [local output] Collecting session information from 2 workers
[17:29:07.110] [local output]  - Worker #1 of 2
[17:29:07.111] [local output]  - Worker #2 of 2
[17:29:07.111] [local output] makeClusterPSOCK() ... done
[17:29:07.129] Packages needed by the future expression (n = 0): <none>
[17:29:07.129] Packages needed by future strategies (n = 0): <none>
[17:29:07.130] {
[17:29:07.130]     {
[17:29:07.130]         {
[17:29:07.130]             ...future.startTime <- base::Sys.time()
[17:29:07.130]             {
[17:29:07.130]                 {
[17:29:07.130]                   {
[17:29:07.130]                     {
[17:29:07.130]                       base::local({
[17:29:07.130]                         has_future <- base::requireNamespace("future", 
[17:29:07.130]                           quietly = TRUE)
[17:29:07.130]                         if (has_future) {
[17:29:07.130]                           ns <- base::getNamespace("future")
[17:29:07.130]                           version <- ns[[".package"]][["version"]]
[17:29:07.130]                           if (is.null(version)) 
[17:29:07.130]                             version <- utils::packageVersion("future")
[17:29:07.130]                         }
[17:29:07.130]                         else {
[17:29:07.130]                           version <- NULL
[17:29:07.130]                         }
[17:29:07.130]                         if (!has_future || version < "1.8.0") {
[17:29:07.130]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:07.130]                             "", base::R.version$version.string), 
[17:29:07.130]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:07.130]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:07.130]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:07.130]                               "release", "version")], collapse = " "), 
[17:29:07.130]                             hostname = base::Sys.info()[["nodename"]])
[17:29:07.130]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:07.130]                             info)
[17:29:07.130]                           info <- base::paste(info, collapse = "; ")
[17:29:07.130]                           if (!has_future) {
[17:29:07.130]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:07.130]                               info)
[17:29:07.130]                           }
[17:29:07.130]                           else {
[17:29:07.130]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:07.130]                               info, version)
[17:29:07.130]                           }
[17:29:07.130]                           base::stop(msg)
[17:29:07.130]                         }
[17:29:07.130]                       })
[17:29:07.130]                     }
[17:29:07.130]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:07.130]                     base::options(mc.cores = 1L)
[17:29:07.130]                   }
[17:29:07.130]                   ...future.strategy.old <- future::plan("list")
[17:29:07.130]                   options(future.plan = NULL)
[17:29:07.130]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:07.130]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:07.130]                 }
[17:29:07.130]                 ...future.workdir <- getwd()
[17:29:07.130]             }
[17:29:07.130]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:07.130]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:07.130]         }
[17:29:07.130]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:07.130]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:07.130]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:07.130]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:07.130]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:07.130]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:07.130]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:07.130]             base::names(...future.oldOptions))
[17:29:07.130]     }
[17:29:07.130]     if (FALSE) {
[17:29:07.130]     }
[17:29:07.130]     else {
[17:29:07.130]         if (TRUE) {
[17:29:07.130]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:07.130]                 open = "w")
[17:29:07.130]         }
[17:29:07.130]         else {
[17:29:07.130]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:07.130]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:07.130]         }
[17:29:07.130]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:07.130]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:07.130]             base::sink(type = "output", split = FALSE)
[17:29:07.130]             base::close(...future.stdout)
[17:29:07.130]         }, add = TRUE)
[17:29:07.130]     }
[17:29:07.130]     ...future.frame <- base::sys.nframe()
[17:29:07.130]     ...future.conditions <- base::list()
[17:29:07.130]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:07.130]     if (FALSE) {
[17:29:07.130]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:07.130]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:07.130]     }
[17:29:07.130]     ...future.result <- base::tryCatch({
[17:29:07.130]         base::withCallingHandlers({
[17:29:07.130]             ...future.value <- base::withVisible(base::local({
[17:29:07.130]                 ...future.makeSendCondition <- base::local({
[17:29:07.130]                   sendCondition <- NULL
[17:29:07.130]                   function(frame = 1L) {
[17:29:07.130]                     if (is.function(sendCondition)) 
[17:29:07.130]                       return(sendCondition)
[17:29:07.130]                     ns <- getNamespace("parallel")
[17:29:07.130]                     if (exists("sendData", mode = "function", 
[17:29:07.130]                       envir = ns)) {
[17:29:07.130]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:07.130]                         envir = ns)
[17:29:07.130]                       envir <- sys.frame(frame)
[17:29:07.130]                       master <- NULL
[17:29:07.130]                       while (!identical(envir, .GlobalEnv) && 
[17:29:07.130]                         !identical(envir, emptyenv())) {
[17:29:07.130]                         if (exists("master", mode = "list", envir = envir, 
[17:29:07.130]                           inherits = FALSE)) {
[17:29:07.130]                           master <- get("master", mode = "list", 
[17:29:07.130]                             envir = envir, inherits = FALSE)
[17:29:07.130]                           if (inherits(master, c("SOCKnode", 
[17:29:07.130]                             "SOCK0node"))) {
[17:29:07.130]                             sendCondition <<- function(cond) {
[17:29:07.130]                               data <- list(type = "VALUE", value = cond, 
[17:29:07.130]                                 success = TRUE)
[17:29:07.130]                               parallel_sendData(master, data)
[17:29:07.130]                             }
[17:29:07.130]                             return(sendCondition)
[17:29:07.130]                           }
[17:29:07.130]                         }
[17:29:07.130]                         frame <- frame + 1L
[17:29:07.130]                         envir <- sys.frame(frame)
[17:29:07.130]                       }
[17:29:07.130]                     }
[17:29:07.130]                     sendCondition <<- function(cond) NULL
[17:29:07.130]                   }
[17:29:07.130]                 })
[17:29:07.130]                 withCallingHandlers({
[17:29:07.130]                   NA
[17:29:07.130]                 }, immediateCondition = function(cond) {
[17:29:07.130]                   sendCondition <- ...future.makeSendCondition()
[17:29:07.130]                   sendCondition(cond)
[17:29:07.130]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:07.130]                   {
[17:29:07.130]                     inherits <- base::inherits
[17:29:07.130]                     invokeRestart <- base::invokeRestart
[17:29:07.130]                     is.null <- base::is.null
[17:29:07.130]                     muffled <- FALSE
[17:29:07.130]                     if (inherits(cond, "message")) {
[17:29:07.130]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:07.130]                       if (muffled) 
[17:29:07.130]                         invokeRestart("muffleMessage")
[17:29:07.130]                     }
[17:29:07.130]                     else if (inherits(cond, "warning")) {
[17:29:07.130]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:07.130]                       if (muffled) 
[17:29:07.130]                         invokeRestart("muffleWarning")
[17:29:07.130]                     }
[17:29:07.130]                     else if (inherits(cond, "condition")) {
[17:29:07.130]                       if (!is.null(pattern)) {
[17:29:07.130]                         computeRestarts <- base::computeRestarts
[17:29:07.130]                         grepl <- base::grepl
[17:29:07.130]                         restarts <- computeRestarts(cond)
[17:29:07.130]                         for (restart in restarts) {
[17:29:07.130]                           name <- restart$name
[17:29:07.130]                           if (is.null(name)) 
[17:29:07.130]                             next
[17:29:07.130]                           if (!grepl(pattern, name)) 
[17:29:07.130]                             next
[17:29:07.130]                           invokeRestart(restart)
[17:29:07.130]                           muffled <- TRUE
[17:29:07.130]                           break
[17:29:07.130]                         }
[17:29:07.130]                       }
[17:29:07.130]                     }
[17:29:07.130]                     invisible(muffled)
[17:29:07.130]                   }
[17:29:07.130]                   muffleCondition(cond)
[17:29:07.130]                 })
[17:29:07.130]             }))
[17:29:07.130]             future::FutureResult(value = ...future.value$value, 
[17:29:07.130]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:07.130]                   ...future.rng), globalenv = if (FALSE) 
[17:29:07.130]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:07.130]                     ...future.globalenv.names))
[17:29:07.130]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:07.130]         }, condition = base::local({
[17:29:07.130]             c <- base::c
[17:29:07.130]             inherits <- base::inherits
[17:29:07.130]             invokeRestart <- base::invokeRestart
[17:29:07.130]             length <- base::length
[17:29:07.130]             list <- base::list
[17:29:07.130]             seq.int <- base::seq.int
[17:29:07.130]             signalCondition <- base::signalCondition
[17:29:07.130]             sys.calls <- base::sys.calls
[17:29:07.130]             `[[` <- base::`[[`
[17:29:07.130]             `+` <- base::`+`
[17:29:07.130]             `<<-` <- base::`<<-`
[17:29:07.130]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:07.130]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:07.130]                   3L)]
[17:29:07.130]             }
[17:29:07.130]             function(cond) {
[17:29:07.130]                 is_error <- inherits(cond, "error")
[17:29:07.130]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:07.130]                   NULL)
[17:29:07.130]                 if (is_error) {
[17:29:07.130]                   sessionInformation <- function() {
[17:29:07.130]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:07.130]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:07.130]                       search = base::search(), system = base::Sys.info())
[17:29:07.130]                   }
[17:29:07.130]                   ...future.conditions[[length(...future.conditions) + 
[17:29:07.130]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:07.130]                     cond$call), session = sessionInformation(), 
[17:29:07.130]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:07.130]                   signalCondition(cond)
[17:29:07.130]                 }
[17:29:07.130]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:07.130]                 "immediateCondition"))) {
[17:29:07.130]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:07.130]                   ...future.conditions[[length(...future.conditions) + 
[17:29:07.130]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:07.130]                   if (TRUE && !signal) {
[17:29:07.130]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:07.130]                     {
[17:29:07.130]                       inherits <- base::inherits
[17:29:07.130]                       invokeRestart <- base::invokeRestart
[17:29:07.130]                       is.null <- base::is.null
[17:29:07.130]                       muffled <- FALSE
[17:29:07.130]                       if (inherits(cond, "message")) {
[17:29:07.130]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:07.130]                         if (muffled) 
[17:29:07.130]                           invokeRestart("muffleMessage")
[17:29:07.130]                       }
[17:29:07.130]                       else if (inherits(cond, "warning")) {
[17:29:07.130]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:07.130]                         if (muffled) 
[17:29:07.130]                           invokeRestart("muffleWarning")
[17:29:07.130]                       }
[17:29:07.130]                       else if (inherits(cond, "condition")) {
[17:29:07.130]                         if (!is.null(pattern)) {
[17:29:07.130]                           computeRestarts <- base::computeRestarts
[17:29:07.130]                           grepl <- base::grepl
[17:29:07.130]                           restarts <- computeRestarts(cond)
[17:29:07.130]                           for (restart in restarts) {
[17:29:07.130]                             name <- restart$name
[17:29:07.130]                             if (is.null(name)) 
[17:29:07.130]                               next
[17:29:07.130]                             if (!grepl(pattern, name)) 
[17:29:07.130]                               next
[17:29:07.130]                             invokeRestart(restart)
[17:29:07.130]                             muffled <- TRUE
[17:29:07.130]                             break
[17:29:07.130]                           }
[17:29:07.130]                         }
[17:29:07.130]                       }
[17:29:07.130]                       invisible(muffled)
[17:29:07.130]                     }
[17:29:07.130]                     muffleCondition(cond, pattern = "^muffle")
[17:29:07.130]                   }
[17:29:07.130]                 }
[17:29:07.130]                 else {
[17:29:07.130]                   if (TRUE) {
[17:29:07.130]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:07.130]                     {
[17:29:07.130]                       inherits <- base::inherits
[17:29:07.130]                       invokeRestart <- base::invokeRestart
[17:29:07.130]                       is.null <- base::is.null
[17:29:07.130]                       muffled <- FALSE
[17:29:07.130]                       if (inherits(cond, "message")) {
[17:29:07.130]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:07.130]                         if (muffled) 
[17:29:07.130]                           invokeRestart("muffleMessage")
[17:29:07.130]                       }
[17:29:07.130]                       else if (inherits(cond, "warning")) {
[17:29:07.130]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:07.130]                         if (muffled) 
[17:29:07.130]                           invokeRestart("muffleWarning")
[17:29:07.130]                       }
[17:29:07.130]                       else if (inherits(cond, "condition")) {
[17:29:07.130]                         if (!is.null(pattern)) {
[17:29:07.130]                           computeRestarts <- base::computeRestarts
[17:29:07.130]                           grepl <- base::grepl
[17:29:07.130]                           restarts <- computeRestarts(cond)
[17:29:07.130]                           for (restart in restarts) {
[17:29:07.130]                             name <- restart$name
[17:29:07.130]                             if (is.null(name)) 
[17:29:07.130]                               next
[17:29:07.130]                             if (!grepl(pattern, name)) 
[17:29:07.130]                               next
[17:29:07.130]                             invokeRestart(restart)
[17:29:07.130]                             muffled <- TRUE
[17:29:07.130]                             break
[17:29:07.130]                           }
[17:29:07.130]                         }
[17:29:07.130]                       }
[17:29:07.130]                       invisible(muffled)
[17:29:07.130]                     }
[17:29:07.130]                     muffleCondition(cond, pattern = "^muffle")
[17:29:07.130]                   }
[17:29:07.130]                 }
[17:29:07.130]             }
[17:29:07.130]         }))
[17:29:07.130]     }, error = function(ex) {
[17:29:07.130]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:07.130]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:07.130]                 ...future.rng), started = ...future.startTime, 
[17:29:07.130]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:07.130]             version = "1.8"), class = "FutureResult")
[17:29:07.130]     }, finally = {
[17:29:07.130]         if (!identical(...future.workdir, getwd())) 
[17:29:07.130]             setwd(...future.workdir)
[17:29:07.130]         {
[17:29:07.130]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:07.130]                 ...future.oldOptions$nwarnings <- NULL
[17:29:07.130]             }
[17:29:07.130]             base::options(...future.oldOptions)
[17:29:07.130]             if (.Platform$OS.type == "windows") {
[17:29:07.130]                 old_names <- names(...future.oldEnvVars)
[17:29:07.130]                 envs <- base::Sys.getenv()
[17:29:07.130]                 names <- names(envs)
[17:29:07.130]                 common <- intersect(names, old_names)
[17:29:07.130]                 added <- setdiff(names, old_names)
[17:29:07.130]                 removed <- setdiff(old_names, names)
[17:29:07.130]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:07.130]                   envs[common]]
[17:29:07.130]                 NAMES <- toupper(changed)
[17:29:07.130]                 args <- list()
[17:29:07.130]                 for (kk in seq_along(NAMES)) {
[17:29:07.130]                   name <- changed[[kk]]
[17:29:07.130]                   NAME <- NAMES[[kk]]
[17:29:07.130]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:07.130]                     next
[17:29:07.130]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:07.130]                 }
[17:29:07.130]                 NAMES <- toupper(added)
[17:29:07.130]                 for (kk in seq_along(NAMES)) {
[17:29:07.130]                   name <- added[[kk]]
[17:29:07.130]                   NAME <- NAMES[[kk]]
[17:29:07.130]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:07.130]                     next
[17:29:07.130]                   args[[name]] <- ""
[17:29:07.130]                 }
[17:29:07.130]                 NAMES <- toupper(removed)
[17:29:07.130]                 for (kk in seq_along(NAMES)) {
[17:29:07.130]                   name <- removed[[kk]]
[17:29:07.130]                   NAME <- NAMES[[kk]]
[17:29:07.130]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:07.130]                     next
[17:29:07.130]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:07.130]                 }
[17:29:07.130]                 if (length(args) > 0) 
[17:29:07.130]                   base::do.call(base::Sys.setenv, args = args)
[17:29:07.130]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:07.130]             }
[17:29:07.130]             else {
[17:29:07.130]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:07.130]             }
[17:29:07.130]             {
[17:29:07.130]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:07.130]                   0L) {
[17:29:07.130]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:07.130]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:07.130]                   base::options(opts)
[17:29:07.130]                 }
[17:29:07.130]                 {
[17:29:07.130]                   {
[17:29:07.130]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:07.130]                     NULL
[17:29:07.130]                   }
[17:29:07.130]                   options(future.plan = NULL)
[17:29:07.130]                   if (is.na(NA_character_)) 
[17:29:07.130]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:07.130]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:07.130]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:07.130]                     .init = FALSE)
[17:29:07.130]                 }
[17:29:07.130]             }
[17:29:07.130]         }
[17:29:07.130]     })
[17:29:07.130]     if (TRUE) {
[17:29:07.130]         base::sink(type = "output", split = FALSE)
[17:29:07.130]         if (TRUE) {
[17:29:07.130]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:07.130]         }
[17:29:07.130]         else {
[17:29:07.130]             ...future.result["stdout"] <- base::list(NULL)
[17:29:07.130]         }
[17:29:07.130]         base::close(...future.stdout)
[17:29:07.130]         ...future.stdout <- NULL
[17:29:07.130]     }
[17:29:07.130]     ...future.result$conditions <- ...future.conditions
[17:29:07.130]     ...future.result$finished <- base::Sys.time()
[17:29:07.130]     ...future.result
[17:29:07.130] }
[17:29:07.262] MultisessionFuture started
[17:29:07.263] result() for ClusterFuture ...
[17:29:07.263] receiveMessageFromWorker() for ClusterFuture ...
[17:29:07.264] - Validating connection of MultisessionFuture
[17:29:07.342] - received message: FutureResult
[17:29:07.342] - Received FutureResult
[17:29:07.347] - Erased future from FutureRegistry
[17:29:07.348] result() for ClusterFuture ...
[17:29:07.348] - result already collected: FutureResult
[17:29:07.348] result() for ClusterFuture ... done
[17:29:07.349] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:07.349] result() for ClusterFuture ... done
[17:29:07.349] result() for ClusterFuture ...
[17:29:07.349] - result already collected: FutureResult
[17:29:07.350] result() for ClusterFuture ... done
[17:29:07.350] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[17:29:07.354] plan(): nbrOfWorkers() = 2
*** resolve() for Future objects ...
- result = FALSE, recursive = FALSE ...
[17:29:07.357] getGlobalsAndPackages() ...
[17:29:07.358] Searching for globals...
[17:29:07.360] - globals found: [3] '{', 'Sys.sleep', 'list'
[17:29:07.360] Searching for globals ... DONE
[17:29:07.360] Resolving globals: FALSE
[17:29:07.361] 
[17:29:07.361] 
[17:29:07.361] getGlobalsAndPackages() ... DONE
[17:29:07.362] run() for 'Future' ...
[17:29:07.362] - state: 'created'
[17:29:07.362] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:07.377] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:07.377] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:07.378]   - Field: 'node'
[17:29:07.378]   - Field: 'label'
[17:29:07.378]   - Field: 'local'
[17:29:07.378]   - Field: 'owner'
[17:29:07.378]   - Field: 'envir'
[17:29:07.378]   - Field: 'workers'
[17:29:07.379]   - Field: 'packages'
[17:29:07.379]   - Field: 'gc'
[17:29:07.379]   - Field: 'conditions'
[17:29:07.379]   - Field: 'persistent'
[17:29:07.379]   - Field: 'expr'
[17:29:07.379]   - Field: 'uuid'
[17:29:07.380]   - Field: 'seed'
[17:29:07.380]   - Field: 'version'
[17:29:07.380]   - Field: 'result'
[17:29:07.380]   - Field: 'asynchronous'
[17:29:07.380]   - Field: 'calls'
[17:29:07.381]   - Field: 'globals'
[17:29:07.381]   - Field: 'stdout'
[17:29:07.381]   - Field: 'earlySignal'
[17:29:07.381]   - Field: 'lazy'
[17:29:07.381]   - Field: 'state'
[17:29:07.381] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:07.382] - Launch lazy future ...
[17:29:07.382] Packages needed by the future expression (n = 0): <none>
[17:29:07.382] Packages needed by future strategies (n = 0): <none>
[17:29:07.383] {
[17:29:07.383]     {
[17:29:07.383]         {
[17:29:07.383]             ...future.startTime <- base::Sys.time()
[17:29:07.383]             {
[17:29:07.383]                 {
[17:29:07.383]                   {
[17:29:07.383]                     {
[17:29:07.383]                       base::local({
[17:29:07.383]                         has_future <- base::requireNamespace("future", 
[17:29:07.383]                           quietly = TRUE)
[17:29:07.383]                         if (has_future) {
[17:29:07.383]                           ns <- base::getNamespace("future")
[17:29:07.383]                           version <- ns[[".package"]][["version"]]
[17:29:07.383]                           if (is.null(version)) 
[17:29:07.383]                             version <- utils::packageVersion("future")
[17:29:07.383]                         }
[17:29:07.383]                         else {
[17:29:07.383]                           version <- NULL
[17:29:07.383]                         }
[17:29:07.383]                         if (!has_future || version < "1.8.0") {
[17:29:07.383]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:07.383]                             "", base::R.version$version.string), 
[17:29:07.383]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:07.383]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:07.383]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:07.383]                               "release", "version")], collapse = " "), 
[17:29:07.383]                             hostname = base::Sys.info()[["nodename"]])
[17:29:07.383]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:07.383]                             info)
[17:29:07.383]                           info <- base::paste(info, collapse = "; ")
[17:29:07.383]                           if (!has_future) {
[17:29:07.383]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:07.383]                               info)
[17:29:07.383]                           }
[17:29:07.383]                           else {
[17:29:07.383]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:07.383]                               info, version)
[17:29:07.383]                           }
[17:29:07.383]                           base::stop(msg)
[17:29:07.383]                         }
[17:29:07.383]                       })
[17:29:07.383]                     }
[17:29:07.383]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:07.383]                     base::options(mc.cores = 1L)
[17:29:07.383]                   }
[17:29:07.383]                   ...future.strategy.old <- future::plan("list")
[17:29:07.383]                   options(future.plan = NULL)
[17:29:07.383]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:07.383]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:07.383]                 }
[17:29:07.383]                 ...future.workdir <- getwd()
[17:29:07.383]             }
[17:29:07.383]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:07.383]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:07.383]         }
[17:29:07.383]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:07.383]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:07.383]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:07.383]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:07.383]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:07.383]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:07.383]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:07.383]             base::names(...future.oldOptions))
[17:29:07.383]     }
[17:29:07.383]     if (FALSE) {
[17:29:07.383]     }
[17:29:07.383]     else {
[17:29:07.383]         if (TRUE) {
[17:29:07.383]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:07.383]                 open = "w")
[17:29:07.383]         }
[17:29:07.383]         else {
[17:29:07.383]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:07.383]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:07.383]         }
[17:29:07.383]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:07.383]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:07.383]             base::sink(type = "output", split = FALSE)
[17:29:07.383]             base::close(...future.stdout)
[17:29:07.383]         }, add = TRUE)
[17:29:07.383]     }
[17:29:07.383]     ...future.frame <- base::sys.nframe()
[17:29:07.383]     ...future.conditions <- base::list()
[17:29:07.383]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:07.383]     if (FALSE) {
[17:29:07.383]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:07.383]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:07.383]     }
[17:29:07.383]     ...future.result <- base::tryCatch({
[17:29:07.383]         base::withCallingHandlers({
[17:29:07.383]             ...future.value <- base::withVisible(base::local({
[17:29:07.383]                 ...future.makeSendCondition <- base::local({
[17:29:07.383]                   sendCondition <- NULL
[17:29:07.383]                   function(frame = 1L) {
[17:29:07.383]                     if (is.function(sendCondition)) 
[17:29:07.383]                       return(sendCondition)
[17:29:07.383]                     ns <- getNamespace("parallel")
[17:29:07.383]                     if (exists("sendData", mode = "function", 
[17:29:07.383]                       envir = ns)) {
[17:29:07.383]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:07.383]                         envir = ns)
[17:29:07.383]                       envir <- sys.frame(frame)
[17:29:07.383]                       master <- NULL
[17:29:07.383]                       while (!identical(envir, .GlobalEnv) && 
[17:29:07.383]                         !identical(envir, emptyenv())) {
[17:29:07.383]                         if (exists("master", mode = "list", envir = envir, 
[17:29:07.383]                           inherits = FALSE)) {
[17:29:07.383]                           master <- get("master", mode = "list", 
[17:29:07.383]                             envir = envir, inherits = FALSE)
[17:29:07.383]                           if (inherits(master, c("SOCKnode", 
[17:29:07.383]                             "SOCK0node"))) {
[17:29:07.383]                             sendCondition <<- function(cond) {
[17:29:07.383]                               data <- list(type = "VALUE", value = cond, 
[17:29:07.383]                                 success = TRUE)
[17:29:07.383]                               parallel_sendData(master, data)
[17:29:07.383]                             }
[17:29:07.383]                             return(sendCondition)
[17:29:07.383]                           }
[17:29:07.383]                         }
[17:29:07.383]                         frame <- frame + 1L
[17:29:07.383]                         envir <- sys.frame(frame)
[17:29:07.383]                       }
[17:29:07.383]                     }
[17:29:07.383]                     sendCondition <<- function(cond) NULL
[17:29:07.383]                   }
[17:29:07.383]                 })
[17:29:07.383]                 withCallingHandlers({
[17:29:07.383]                   {
[17:29:07.383]                     Sys.sleep(0.5)
[17:29:07.383]                     list(a = 1, b = 42L)
[17:29:07.383]                   }
[17:29:07.383]                 }, immediateCondition = function(cond) {
[17:29:07.383]                   sendCondition <- ...future.makeSendCondition()
[17:29:07.383]                   sendCondition(cond)
[17:29:07.383]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:07.383]                   {
[17:29:07.383]                     inherits <- base::inherits
[17:29:07.383]                     invokeRestart <- base::invokeRestart
[17:29:07.383]                     is.null <- base::is.null
[17:29:07.383]                     muffled <- FALSE
[17:29:07.383]                     if (inherits(cond, "message")) {
[17:29:07.383]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:07.383]                       if (muffled) 
[17:29:07.383]                         invokeRestart("muffleMessage")
[17:29:07.383]                     }
[17:29:07.383]                     else if (inherits(cond, "warning")) {
[17:29:07.383]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:07.383]                       if (muffled) 
[17:29:07.383]                         invokeRestart("muffleWarning")
[17:29:07.383]                     }
[17:29:07.383]                     else if (inherits(cond, "condition")) {
[17:29:07.383]                       if (!is.null(pattern)) {
[17:29:07.383]                         computeRestarts <- base::computeRestarts
[17:29:07.383]                         grepl <- base::grepl
[17:29:07.383]                         restarts <- computeRestarts(cond)
[17:29:07.383]                         for (restart in restarts) {
[17:29:07.383]                           name <- restart$name
[17:29:07.383]                           if (is.null(name)) 
[17:29:07.383]                             next
[17:29:07.383]                           if (!grepl(pattern, name)) 
[17:29:07.383]                             next
[17:29:07.383]                           invokeRestart(restart)
[17:29:07.383]                           muffled <- TRUE
[17:29:07.383]                           break
[17:29:07.383]                         }
[17:29:07.383]                       }
[17:29:07.383]                     }
[17:29:07.383]                     invisible(muffled)
[17:29:07.383]                   }
[17:29:07.383]                   muffleCondition(cond)
[17:29:07.383]                 })
[17:29:07.383]             }))
[17:29:07.383]             future::FutureResult(value = ...future.value$value, 
[17:29:07.383]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:07.383]                   ...future.rng), globalenv = if (FALSE) 
[17:29:07.383]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:07.383]                     ...future.globalenv.names))
[17:29:07.383]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:07.383]         }, condition = base::local({
[17:29:07.383]             c <- base::c
[17:29:07.383]             inherits <- base::inherits
[17:29:07.383]             invokeRestart <- base::invokeRestart
[17:29:07.383]             length <- base::length
[17:29:07.383]             list <- base::list
[17:29:07.383]             seq.int <- base::seq.int
[17:29:07.383]             signalCondition <- base::signalCondition
[17:29:07.383]             sys.calls <- base::sys.calls
[17:29:07.383]             `[[` <- base::`[[`
[17:29:07.383]             `+` <- base::`+`
[17:29:07.383]             `<<-` <- base::`<<-`
[17:29:07.383]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:07.383]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:07.383]                   3L)]
[17:29:07.383]             }
[17:29:07.383]             function(cond) {
[17:29:07.383]                 is_error <- inherits(cond, "error")
[17:29:07.383]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:07.383]                   NULL)
[17:29:07.383]                 if (is_error) {
[17:29:07.383]                   sessionInformation <- function() {
[17:29:07.383]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:07.383]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:07.383]                       search = base::search(), system = base::Sys.info())
[17:29:07.383]                   }
[17:29:07.383]                   ...future.conditions[[length(...future.conditions) + 
[17:29:07.383]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:07.383]                     cond$call), session = sessionInformation(), 
[17:29:07.383]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:07.383]                   signalCondition(cond)
[17:29:07.383]                 }
[17:29:07.383]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:07.383]                 "immediateCondition"))) {
[17:29:07.383]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:07.383]                   ...future.conditions[[length(...future.conditions) + 
[17:29:07.383]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:07.383]                   if (TRUE && !signal) {
[17:29:07.383]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:07.383]                     {
[17:29:07.383]                       inherits <- base::inherits
[17:29:07.383]                       invokeRestart <- base::invokeRestart
[17:29:07.383]                       is.null <- base::is.null
[17:29:07.383]                       muffled <- FALSE
[17:29:07.383]                       if (inherits(cond, "message")) {
[17:29:07.383]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:07.383]                         if (muffled) 
[17:29:07.383]                           invokeRestart("muffleMessage")
[17:29:07.383]                       }
[17:29:07.383]                       else if (inherits(cond, "warning")) {
[17:29:07.383]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:07.383]                         if (muffled) 
[17:29:07.383]                           invokeRestart("muffleWarning")
[17:29:07.383]                       }
[17:29:07.383]                       else if (inherits(cond, "condition")) {
[17:29:07.383]                         if (!is.null(pattern)) {
[17:29:07.383]                           computeRestarts <- base::computeRestarts
[17:29:07.383]                           grepl <- base::grepl
[17:29:07.383]                           restarts <- computeRestarts(cond)
[17:29:07.383]                           for (restart in restarts) {
[17:29:07.383]                             name <- restart$name
[17:29:07.383]                             if (is.null(name)) 
[17:29:07.383]                               next
[17:29:07.383]                             if (!grepl(pattern, name)) 
[17:29:07.383]                               next
[17:29:07.383]                             invokeRestart(restart)
[17:29:07.383]                             muffled <- TRUE
[17:29:07.383]                             break
[17:29:07.383]                           }
[17:29:07.383]                         }
[17:29:07.383]                       }
[17:29:07.383]                       invisible(muffled)
[17:29:07.383]                     }
[17:29:07.383]                     muffleCondition(cond, pattern = "^muffle")
[17:29:07.383]                   }
[17:29:07.383]                 }
[17:29:07.383]                 else {
[17:29:07.383]                   if (TRUE) {
[17:29:07.383]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:07.383]                     {
[17:29:07.383]                       inherits <- base::inherits
[17:29:07.383]                       invokeRestart <- base::invokeRestart
[17:29:07.383]                       is.null <- base::is.null
[17:29:07.383]                       muffled <- FALSE
[17:29:07.383]                       if (inherits(cond, "message")) {
[17:29:07.383]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:07.383]                         if (muffled) 
[17:29:07.383]                           invokeRestart("muffleMessage")
[17:29:07.383]                       }
[17:29:07.383]                       else if (inherits(cond, "warning")) {
[17:29:07.383]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:07.383]                         if (muffled) 
[17:29:07.383]                           invokeRestart("muffleWarning")
[17:29:07.383]                       }
[17:29:07.383]                       else if (inherits(cond, "condition")) {
[17:29:07.383]                         if (!is.null(pattern)) {
[17:29:07.383]                           computeRestarts <- base::computeRestarts
[17:29:07.383]                           grepl <- base::grepl
[17:29:07.383]                           restarts <- computeRestarts(cond)
[17:29:07.383]                           for (restart in restarts) {
[17:29:07.383]                             name <- restart$name
[17:29:07.383]                             if (is.null(name)) 
[17:29:07.383]                               next
[17:29:07.383]                             if (!grepl(pattern, name)) 
[17:29:07.383]                               next
[17:29:07.383]                             invokeRestart(restart)
[17:29:07.383]                             muffled <- TRUE
[17:29:07.383]                             break
[17:29:07.383]                           }
[17:29:07.383]                         }
[17:29:07.383]                       }
[17:29:07.383]                       invisible(muffled)
[17:29:07.383]                     }
[17:29:07.383]                     muffleCondition(cond, pattern = "^muffle")
[17:29:07.383]                   }
[17:29:07.383]                 }
[17:29:07.383]             }
[17:29:07.383]         }))
[17:29:07.383]     }, error = function(ex) {
[17:29:07.383]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:07.383]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:07.383]                 ...future.rng), started = ...future.startTime, 
[17:29:07.383]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:07.383]             version = "1.8"), class = "FutureResult")
[17:29:07.383]     }, finally = {
[17:29:07.383]         if (!identical(...future.workdir, getwd())) 
[17:29:07.383]             setwd(...future.workdir)
[17:29:07.383]         {
[17:29:07.383]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:07.383]                 ...future.oldOptions$nwarnings <- NULL
[17:29:07.383]             }
[17:29:07.383]             base::options(...future.oldOptions)
[17:29:07.383]             if (.Platform$OS.type == "windows") {
[17:29:07.383]                 old_names <- names(...future.oldEnvVars)
[17:29:07.383]                 envs <- base::Sys.getenv()
[17:29:07.383]                 names <- names(envs)
[17:29:07.383]                 common <- intersect(names, old_names)
[17:29:07.383]                 added <- setdiff(names, old_names)
[17:29:07.383]                 removed <- setdiff(old_names, names)
[17:29:07.383]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:07.383]                   envs[common]]
[17:29:07.383]                 NAMES <- toupper(changed)
[17:29:07.383]                 args <- list()
[17:29:07.383]                 for (kk in seq_along(NAMES)) {
[17:29:07.383]                   name <- changed[[kk]]
[17:29:07.383]                   NAME <- NAMES[[kk]]
[17:29:07.383]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:07.383]                     next
[17:29:07.383]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:07.383]                 }
[17:29:07.383]                 NAMES <- toupper(added)
[17:29:07.383]                 for (kk in seq_along(NAMES)) {
[17:29:07.383]                   name <- added[[kk]]
[17:29:07.383]                   NAME <- NAMES[[kk]]
[17:29:07.383]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:07.383]                     next
[17:29:07.383]                   args[[name]] <- ""
[17:29:07.383]                 }
[17:29:07.383]                 NAMES <- toupper(removed)
[17:29:07.383]                 for (kk in seq_along(NAMES)) {
[17:29:07.383]                   name <- removed[[kk]]
[17:29:07.383]                   NAME <- NAMES[[kk]]
[17:29:07.383]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:07.383]                     next
[17:29:07.383]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:07.383]                 }
[17:29:07.383]                 if (length(args) > 0) 
[17:29:07.383]                   base::do.call(base::Sys.setenv, args = args)
[17:29:07.383]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:07.383]             }
[17:29:07.383]             else {
[17:29:07.383]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:07.383]             }
[17:29:07.383]             {
[17:29:07.383]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:07.383]                   0L) {
[17:29:07.383]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:07.383]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:07.383]                   base::options(opts)
[17:29:07.383]                 }
[17:29:07.383]                 {
[17:29:07.383]                   {
[17:29:07.383]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:07.383]                     NULL
[17:29:07.383]                   }
[17:29:07.383]                   options(future.plan = NULL)
[17:29:07.383]                   if (is.na(NA_character_)) 
[17:29:07.383]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:07.383]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:07.383]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:07.383]                     .init = FALSE)
[17:29:07.383]                 }
[17:29:07.383]             }
[17:29:07.383]         }
[17:29:07.383]     })
[17:29:07.383]     if (TRUE) {
[17:29:07.383]         base::sink(type = "output", split = FALSE)
[17:29:07.383]         if (TRUE) {
[17:29:07.383]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:07.383]         }
[17:29:07.383]         else {
[17:29:07.383]             ...future.result["stdout"] <- base::list(NULL)
[17:29:07.383]         }
[17:29:07.383]         base::close(...future.stdout)
[17:29:07.383]         ...future.stdout <- NULL
[17:29:07.383]     }
[17:29:07.383]     ...future.result$conditions <- ...future.conditions
[17:29:07.383]     ...future.result$finished <- base::Sys.time()
[17:29:07.383]     ...future.result
[17:29:07.383] }
[17:29:07.389] MultisessionFuture started
[17:29:07.389] - Launch lazy future ... done
[17:29:07.389] run() for 'MultisessionFuture' ... done
[17:29:07.918] receiveMessageFromWorker() for ClusterFuture ...
[17:29:07.919] - Validating connection of MultisessionFuture
[17:29:07.919] - received message: FutureResult
[17:29:07.920] - Received FutureResult
[17:29:07.920] - Erased future from FutureRegistry
[17:29:07.921] result() for ClusterFuture ...
[17:29:07.921] - result already collected: FutureResult
[17:29:07.921] result() for ClusterFuture ... done
[17:29:07.921] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:07.922] A MultisessionFuture was resolved (result was not collected)
[17:29:07.922] getGlobalsAndPackages() ...
[17:29:07.922] Searching for globals...
[17:29:07.926] - globals found: [3] '{', 'Sys.sleep', 'list'
[17:29:07.926] Searching for globals ... DONE
[17:29:07.926] Resolving globals: FALSE
[17:29:07.927] 
[17:29:07.928] 
[17:29:07.928] getGlobalsAndPackages() ... DONE
[17:29:07.929] run() for 'Future' ...
[17:29:07.929] - state: 'created'
[17:29:07.930] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:07.959] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:07.959] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:07.960]   - Field: 'node'
[17:29:07.960]   - Field: 'label'
[17:29:07.961]   - Field: 'local'
[17:29:07.961]   - Field: 'owner'
[17:29:07.961]   - Field: 'envir'
[17:29:07.962]   - Field: 'workers'
[17:29:07.962]   - Field: 'packages'
[17:29:07.962]   - Field: 'gc'
[17:29:07.963]   - Field: 'conditions'
[17:29:07.963]   - Field: 'persistent'
[17:29:07.964]   - Field: 'expr'
[17:29:07.964]   - Field: 'uuid'
[17:29:07.964]   - Field: 'seed'
[17:29:07.965]   - Field: 'version'
[17:29:07.965]   - Field: 'result'
[17:29:07.966]   - Field: 'asynchronous'
[17:29:07.966]   - Field: 'calls'
[17:29:07.966]   - Field: 'globals'
[17:29:07.967]   - Field: 'stdout'
[17:29:07.967]   - Field: 'earlySignal'
[17:29:07.967]   - Field: 'lazy'
[17:29:07.968]   - Field: 'state'
[17:29:07.968] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:07.969] - Launch lazy future ...
[17:29:07.970] Packages needed by the future expression (n = 0): <none>
[17:29:07.970] Packages needed by future strategies (n = 0): <none>
[17:29:07.971] {
[17:29:07.971]     {
[17:29:07.971]         {
[17:29:07.971]             ...future.startTime <- base::Sys.time()
[17:29:07.971]             {
[17:29:07.971]                 {
[17:29:07.971]                   {
[17:29:07.971]                     {
[17:29:07.971]                       base::local({
[17:29:07.971]                         has_future <- base::requireNamespace("future", 
[17:29:07.971]                           quietly = TRUE)
[17:29:07.971]                         if (has_future) {
[17:29:07.971]                           ns <- base::getNamespace("future")
[17:29:07.971]                           version <- ns[[".package"]][["version"]]
[17:29:07.971]                           if (is.null(version)) 
[17:29:07.971]                             version <- utils::packageVersion("future")
[17:29:07.971]                         }
[17:29:07.971]                         else {
[17:29:07.971]                           version <- NULL
[17:29:07.971]                         }
[17:29:07.971]                         if (!has_future || version < "1.8.0") {
[17:29:07.971]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:07.971]                             "", base::R.version$version.string), 
[17:29:07.971]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:07.971]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:07.971]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:07.971]                               "release", "version")], collapse = " "), 
[17:29:07.971]                             hostname = base::Sys.info()[["nodename"]])
[17:29:07.971]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:07.971]                             info)
[17:29:07.971]                           info <- base::paste(info, collapse = "; ")
[17:29:07.971]                           if (!has_future) {
[17:29:07.971]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:07.971]                               info)
[17:29:07.971]                           }
[17:29:07.971]                           else {
[17:29:07.971]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:07.971]                               info, version)
[17:29:07.971]                           }
[17:29:07.971]                           base::stop(msg)
[17:29:07.971]                         }
[17:29:07.971]                       })
[17:29:07.971]                     }
[17:29:07.971]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:07.971]                     base::options(mc.cores = 1L)
[17:29:07.971]                   }
[17:29:07.971]                   ...future.strategy.old <- future::plan("list")
[17:29:07.971]                   options(future.plan = NULL)
[17:29:07.971]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:07.971]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:07.971]                 }
[17:29:07.971]                 ...future.workdir <- getwd()
[17:29:07.971]             }
[17:29:07.971]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:07.971]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:07.971]         }
[17:29:07.971]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:07.971]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:07.971]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:07.971]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:07.971]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:07.971]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:07.971]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:07.971]             base::names(...future.oldOptions))
[17:29:07.971]     }
[17:29:07.971]     if (FALSE) {
[17:29:07.971]     }
[17:29:07.971]     else {
[17:29:07.971]         if (TRUE) {
[17:29:07.971]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:07.971]                 open = "w")
[17:29:07.971]         }
[17:29:07.971]         else {
[17:29:07.971]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:07.971]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:07.971]         }
[17:29:07.971]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:07.971]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:07.971]             base::sink(type = "output", split = FALSE)
[17:29:07.971]             base::close(...future.stdout)
[17:29:07.971]         }, add = TRUE)
[17:29:07.971]     }
[17:29:07.971]     ...future.frame <- base::sys.nframe()
[17:29:07.971]     ...future.conditions <- base::list()
[17:29:07.971]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:07.971]     if (FALSE) {
[17:29:07.971]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:07.971]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:07.971]     }
[17:29:07.971]     ...future.result <- base::tryCatch({
[17:29:07.971]         base::withCallingHandlers({
[17:29:07.971]             ...future.value <- base::withVisible(base::local({
[17:29:07.971]                 ...future.makeSendCondition <- base::local({
[17:29:07.971]                   sendCondition <- NULL
[17:29:07.971]                   function(frame = 1L) {
[17:29:07.971]                     if (is.function(sendCondition)) 
[17:29:07.971]                       return(sendCondition)
[17:29:07.971]                     ns <- getNamespace("parallel")
[17:29:07.971]                     if (exists("sendData", mode = "function", 
[17:29:07.971]                       envir = ns)) {
[17:29:07.971]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:07.971]                         envir = ns)
[17:29:07.971]                       envir <- sys.frame(frame)
[17:29:07.971]                       master <- NULL
[17:29:07.971]                       while (!identical(envir, .GlobalEnv) && 
[17:29:07.971]                         !identical(envir, emptyenv())) {
[17:29:07.971]                         if (exists("master", mode = "list", envir = envir, 
[17:29:07.971]                           inherits = FALSE)) {
[17:29:07.971]                           master <- get("master", mode = "list", 
[17:29:07.971]                             envir = envir, inherits = FALSE)
[17:29:07.971]                           if (inherits(master, c("SOCKnode", 
[17:29:07.971]                             "SOCK0node"))) {
[17:29:07.971]                             sendCondition <<- function(cond) {
[17:29:07.971]                               data <- list(type = "VALUE", value = cond, 
[17:29:07.971]                                 success = TRUE)
[17:29:07.971]                               parallel_sendData(master, data)
[17:29:07.971]                             }
[17:29:07.971]                             return(sendCondition)
[17:29:07.971]                           }
[17:29:07.971]                         }
[17:29:07.971]                         frame <- frame + 1L
[17:29:07.971]                         envir <- sys.frame(frame)
[17:29:07.971]                       }
[17:29:07.971]                     }
[17:29:07.971]                     sendCondition <<- function(cond) NULL
[17:29:07.971]                   }
[17:29:07.971]                 })
[17:29:07.971]                 withCallingHandlers({
[17:29:07.971]                   {
[17:29:07.971]                     Sys.sleep(0.5)
[17:29:07.971]                     list(a = 1, b = 42L)
[17:29:07.971]                   }
[17:29:07.971]                 }, immediateCondition = function(cond) {
[17:29:07.971]                   sendCondition <- ...future.makeSendCondition()
[17:29:07.971]                   sendCondition(cond)
[17:29:07.971]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:07.971]                   {
[17:29:07.971]                     inherits <- base::inherits
[17:29:07.971]                     invokeRestart <- base::invokeRestart
[17:29:07.971]                     is.null <- base::is.null
[17:29:07.971]                     muffled <- FALSE
[17:29:07.971]                     if (inherits(cond, "message")) {
[17:29:07.971]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:07.971]                       if (muffled) 
[17:29:07.971]                         invokeRestart("muffleMessage")
[17:29:07.971]                     }
[17:29:07.971]                     else if (inherits(cond, "warning")) {
[17:29:07.971]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:07.971]                       if (muffled) 
[17:29:07.971]                         invokeRestart("muffleWarning")
[17:29:07.971]                     }
[17:29:07.971]                     else if (inherits(cond, "condition")) {
[17:29:07.971]                       if (!is.null(pattern)) {
[17:29:07.971]                         computeRestarts <- base::computeRestarts
[17:29:07.971]                         grepl <- base::grepl
[17:29:07.971]                         restarts <- computeRestarts(cond)
[17:29:07.971]                         for (restart in restarts) {
[17:29:07.971]                           name <- restart$name
[17:29:07.971]                           if (is.null(name)) 
[17:29:07.971]                             next
[17:29:07.971]                           if (!grepl(pattern, name)) 
[17:29:07.971]                             next
[17:29:07.971]                           invokeRestart(restart)
[17:29:07.971]                           muffled <- TRUE
[17:29:07.971]                           break
[17:29:07.971]                         }
[17:29:07.971]                       }
[17:29:07.971]                     }
[17:29:07.971]                     invisible(muffled)
[17:29:07.971]                   }
[17:29:07.971]                   muffleCondition(cond)
[17:29:07.971]                 })
[17:29:07.971]             }))
[17:29:07.971]             future::FutureResult(value = ...future.value$value, 
[17:29:07.971]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:07.971]                   ...future.rng), globalenv = if (FALSE) 
[17:29:07.971]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:07.971]                     ...future.globalenv.names))
[17:29:07.971]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:07.971]         }, condition = base::local({
[17:29:07.971]             c <- base::c
[17:29:07.971]             inherits <- base::inherits
[17:29:07.971]             invokeRestart <- base::invokeRestart
[17:29:07.971]             length <- base::length
[17:29:07.971]             list <- base::list
[17:29:07.971]             seq.int <- base::seq.int
[17:29:07.971]             signalCondition <- base::signalCondition
[17:29:07.971]             sys.calls <- base::sys.calls
[17:29:07.971]             `[[` <- base::`[[`
[17:29:07.971]             `+` <- base::`+`
[17:29:07.971]             `<<-` <- base::`<<-`
[17:29:07.971]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:07.971]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:07.971]                   3L)]
[17:29:07.971]             }
[17:29:07.971]             function(cond) {
[17:29:07.971]                 is_error <- inherits(cond, "error")
[17:29:07.971]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:07.971]                   NULL)
[17:29:07.971]                 if (is_error) {
[17:29:07.971]                   sessionInformation <- function() {
[17:29:07.971]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:07.971]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:07.971]                       search = base::search(), system = base::Sys.info())
[17:29:07.971]                   }
[17:29:07.971]                   ...future.conditions[[length(...future.conditions) + 
[17:29:07.971]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:07.971]                     cond$call), session = sessionInformation(), 
[17:29:07.971]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:07.971]                   signalCondition(cond)
[17:29:07.971]                 }
[17:29:07.971]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:07.971]                 "immediateCondition"))) {
[17:29:07.971]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:07.971]                   ...future.conditions[[length(...future.conditions) + 
[17:29:07.971]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:07.971]                   if (TRUE && !signal) {
[17:29:07.971]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:07.971]                     {
[17:29:07.971]                       inherits <- base::inherits
[17:29:07.971]                       invokeRestart <- base::invokeRestart
[17:29:07.971]                       is.null <- base::is.null
[17:29:07.971]                       muffled <- FALSE
[17:29:07.971]                       if (inherits(cond, "message")) {
[17:29:07.971]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:07.971]                         if (muffled) 
[17:29:07.971]                           invokeRestart("muffleMessage")
[17:29:07.971]                       }
[17:29:07.971]                       else if (inherits(cond, "warning")) {
[17:29:07.971]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:07.971]                         if (muffled) 
[17:29:07.971]                           invokeRestart("muffleWarning")
[17:29:07.971]                       }
[17:29:07.971]                       else if (inherits(cond, "condition")) {
[17:29:07.971]                         if (!is.null(pattern)) {
[17:29:07.971]                           computeRestarts <- base::computeRestarts
[17:29:07.971]                           grepl <- base::grepl
[17:29:07.971]                           restarts <- computeRestarts(cond)
[17:29:07.971]                           for (restart in restarts) {
[17:29:07.971]                             name <- restart$name
[17:29:07.971]                             if (is.null(name)) 
[17:29:07.971]                               next
[17:29:07.971]                             if (!grepl(pattern, name)) 
[17:29:07.971]                               next
[17:29:07.971]                             invokeRestart(restart)
[17:29:07.971]                             muffled <- TRUE
[17:29:07.971]                             break
[17:29:07.971]                           }
[17:29:07.971]                         }
[17:29:07.971]                       }
[17:29:07.971]                       invisible(muffled)
[17:29:07.971]                     }
[17:29:07.971]                     muffleCondition(cond, pattern = "^muffle")
[17:29:07.971]                   }
[17:29:07.971]                 }
[17:29:07.971]                 else {
[17:29:07.971]                   if (TRUE) {
[17:29:07.971]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:07.971]                     {
[17:29:07.971]                       inherits <- base::inherits
[17:29:07.971]                       invokeRestart <- base::invokeRestart
[17:29:07.971]                       is.null <- base::is.null
[17:29:07.971]                       muffled <- FALSE
[17:29:07.971]                       if (inherits(cond, "message")) {
[17:29:07.971]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:07.971]                         if (muffled) 
[17:29:07.971]                           invokeRestart("muffleMessage")
[17:29:07.971]                       }
[17:29:07.971]                       else if (inherits(cond, "warning")) {
[17:29:07.971]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:07.971]                         if (muffled) 
[17:29:07.971]                           invokeRestart("muffleWarning")
[17:29:07.971]                       }
[17:29:07.971]                       else if (inherits(cond, "condition")) {
[17:29:07.971]                         if (!is.null(pattern)) {
[17:29:07.971]                           computeRestarts <- base::computeRestarts
[17:29:07.971]                           grepl <- base::grepl
[17:29:07.971]                           restarts <- computeRestarts(cond)
[17:29:07.971]                           for (restart in restarts) {
[17:29:07.971]                             name <- restart$name
[17:29:07.971]                             if (is.null(name)) 
[17:29:07.971]                               next
[17:29:07.971]                             if (!grepl(pattern, name)) 
[17:29:07.971]                               next
[17:29:07.971]                             invokeRestart(restart)
[17:29:07.971]                             muffled <- TRUE
[17:29:07.971]                             break
[17:29:07.971]                           }
[17:29:07.971]                         }
[17:29:07.971]                       }
[17:29:07.971]                       invisible(muffled)
[17:29:07.971]                     }
[17:29:07.971]                     muffleCondition(cond, pattern = "^muffle")
[17:29:07.971]                   }
[17:29:07.971]                 }
[17:29:07.971]             }
[17:29:07.971]         }))
[17:29:07.971]     }, error = function(ex) {
[17:29:07.971]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:07.971]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:07.971]                 ...future.rng), started = ...future.startTime, 
[17:29:07.971]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:07.971]             version = "1.8"), class = "FutureResult")
[17:29:07.971]     }, finally = {
[17:29:07.971]         if (!identical(...future.workdir, getwd())) 
[17:29:07.971]             setwd(...future.workdir)
[17:29:07.971]         {
[17:29:07.971]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:07.971]                 ...future.oldOptions$nwarnings <- NULL
[17:29:07.971]             }
[17:29:07.971]             base::options(...future.oldOptions)
[17:29:07.971]             if (.Platform$OS.type == "windows") {
[17:29:07.971]                 old_names <- names(...future.oldEnvVars)
[17:29:07.971]                 envs <- base::Sys.getenv()
[17:29:07.971]                 names <- names(envs)
[17:29:07.971]                 common <- intersect(names, old_names)
[17:29:07.971]                 added <- setdiff(names, old_names)
[17:29:07.971]                 removed <- setdiff(old_names, names)
[17:29:07.971]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:07.971]                   envs[common]]
[17:29:07.971]                 NAMES <- toupper(changed)
[17:29:07.971]                 args <- list()
[17:29:07.971]                 for (kk in seq_along(NAMES)) {
[17:29:07.971]                   name <- changed[[kk]]
[17:29:07.971]                   NAME <- NAMES[[kk]]
[17:29:07.971]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:07.971]                     next
[17:29:07.971]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:07.971]                 }
[17:29:07.971]                 NAMES <- toupper(added)
[17:29:07.971]                 for (kk in seq_along(NAMES)) {
[17:29:07.971]                   name <- added[[kk]]
[17:29:07.971]                   NAME <- NAMES[[kk]]
[17:29:07.971]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:07.971]                     next
[17:29:07.971]                   args[[name]] <- ""
[17:29:07.971]                 }
[17:29:07.971]                 NAMES <- toupper(removed)
[17:29:07.971]                 for (kk in seq_along(NAMES)) {
[17:29:07.971]                   name <- removed[[kk]]
[17:29:07.971]                   NAME <- NAMES[[kk]]
[17:29:07.971]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:07.971]                     next
[17:29:07.971]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:07.971]                 }
[17:29:07.971]                 if (length(args) > 0) 
[17:29:07.971]                   base::do.call(base::Sys.setenv, args = args)
[17:29:07.971]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:07.971]             }
[17:29:07.971]             else {
[17:29:07.971]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:07.971]             }
[17:29:07.971]             {
[17:29:07.971]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:07.971]                   0L) {
[17:29:07.971]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:07.971]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:07.971]                   base::options(opts)
[17:29:07.971]                 }
[17:29:07.971]                 {
[17:29:07.971]                   {
[17:29:07.971]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:07.971]                     NULL
[17:29:07.971]                   }
[17:29:07.971]                   options(future.plan = NULL)
[17:29:07.971]                   if (is.na(NA_character_)) 
[17:29:07.971]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:07.971]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:07.971]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:07.971]                     .init = FALSE)
[17:29:07.971]                 }
[17:29:07.971]             }
[17:29:07.971]         }
[17:29:07.971]     })
[17:29:07.971]     if (TRUE) {
[17:29:07.971]         base::sink(type = "output", split = FALSE)
[17:29:07.971]         if (TRUE) {
[17:29:07.971]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:07.971]         }
[17:29:07.971]         else {
[17:29:07.971]             ...future.result["stdout"] <- base::list(NULL)
[17:29:07.971]         }
[17:29:07.971]         base::close(...future.stdout)
[17:29:07.971]         ...future.stdout <- NULL
[17:29:07.971]     }
[17:29:07.971]     ...future.result$conditions <- ...future.conditions
[17:29:07.971]     ...future.result$finished <- base::Sys.time()
[17:29:07.971]     ...future.result
[17:29:07.971] }
[17:29:07.981] MultisessionFuture started
[17:29:07.981] - Launch lazy future ... done
[17:29:07.982] run() for 'MultisessionFuture' ... done
[17:29:08.509] receiveMessageFromWorker() for ClusterFuture ...
[17:29:08.509] - Validating connection of MultisessionFuture
[17:29:08.510] - received message: FutureResult
[17:29:08.510] - Received FutureResult
[17:29:08.511] - Erased future from FutureRegistry
[17:29:08.511] result() for ClusterFuture ...
[17:29:08.511] - result already collected: FutureResult
[17:29:08.512] result() for ClusterFuture ... done
[17:29:08.512] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:08.512] A MultisessionFuture was resolved (result was not collected)
- w/ exception ...
[17:29:08.513] getGlobalsAndPackages() ...
[17:29:08.513] Searching for globals...
[17:29:08.515] - globals found: [2] 'list', 'stop'
[17:29:08.515] Searching for globals ... DONE
[17:29:08.516] Resolving globals: FALSE
[17:29:08.516] 
[17:29:08.517] 
[17:29:08.517] getGlobalsAndPackages() ... DONE
[17:29:08.517] run() for 'Future' ...
[17:29:08.518] - state: 'created'
[17:29:08.518] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:08.540] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:08.540] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:08.541]   - Field: 'node'
[17:29:08.541]   - Field: 'label'
[17:29:08.541]   - Field: 'local'
[17:29:08.541]   - Field: 'owner'
[17:29:08.542]   - Field: 'envir'
[17:29:08.542]   - Field: 'workers'
[17:29:08.543]   - Field: 'packages'
[17:29:08.543]   - Field: 'gc'
[17:29:08.543]   - Field: 'conditions'
[17:29:08.544]   - Field: 'persistent'
[17:29:08.544]   - Field: 'expr'
[17:29:08.544]   - Field: 'uuid'
[17:29:08.545]   - Field: 'seed'
[17:29:08.545]   - Field: 'version'
[17:29:08.545]   - Field: 'result'
[17:29:08.546]   - Field: 'asynchronous'
[17:29:08.546]   - Field: 'calls'
[17:29:08.547]   - Field: 'globals'
[17:29:08.547]   - Field: 'stdout'
[17:29:08.547]   - Field: 'earlySignal'
[17:29:08.548]   - Field: 'lazy'
[17:29:08.548]   - Field: 'state'
[17:29:08.549] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:08.549] - Launch lazy future ...
[17:29:08.550] Packages needed by the future expression (n = 0): <none>
[17:29:08.550] Packages needed by future strategies (n = 0): <none>
[17:29:08.551] {
[17:29:08.551]     {
[17:29:08.551]         {
[17:29:08.551]             ...future.startTime <- base::Sys.time()
[17:29:08.551]             {
[17:29:08.551]                 {
[17:29:08.551]                   {
[17:29:08.551]                     {
[17:29:08.551]                       base::local({
[17:29:08.551]                         has_future <- base::requireNamespace("future", 
[17:29:08.551]                           quietly = TRUE)
[17:29:08.551]                         if (has_future) {
[17:29:08.551]                           ns <- base::getNamespace("future")
[17:29:08.551]                           version <- ns[[".package"]][["version"]]
[17:29:08.551]                           if (is.null(version)) 
[17:29:08.551]                             version <- utils::packageVersion("future")
[17:29:08.551]                         }
[17:29:08.551]                         else {
[17:29:08.551]                           version <- NULL
[17:29:08.551]                         }
[17:29:08.551]                         if (!has_future || version < "1.8.0") {
[17:29:08.551]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:08.551]                             "", base::R.version$version.string), 
[17:29:08.551]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:08.551]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:08.551]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:08.551]                               "release", "version")], collapse = " "), 
[17:29:08.551]                             hostname = base::Sys.info()[["nodename"]])
[17:29:08.551]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:08.551]                             info)
[17:29:08.551]                           info <- base::paste(info, collapse = "; ")
[17:29:08.551]                           if (!has_future) {
[17:29:08.551]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:08.551]                               info)
[17:29:08.551]                           }
[17:29:08.551]                           else {
[17:29:08.551]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:08.551]                               info, version)
[17:29:08.551]                           }
[17:29:08.551]                           base::stop(msg)
[17:29:08.551]                         }
[17:29:08.551]                       })
[17:29:08.551]                     }
[17:29:08.551]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:08.551]                     base::options(mc.cores = 1L)
[17:29:08.551]                   }
[17:29:08.551]                   ...future.strategy.old <- future::plan("list")
[17:29:08.551]                   options(future.plan = NULL)
[17:29:08.551]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:08.551]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:08.551]                 }
[17:29:08.551]                 ...future.workdir <- getwd()
[17:29:08.551]             }
[17:29:08.551]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:08.551]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:08.551]         }
[17:29:08.551]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:08.551]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:08.551]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:08.551]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:08.551]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:08.551]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:08.551]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:08.551]             base::names(...future.oldOptions))
[17:29:08.551]     }
[17:29:08.551]     if (FALSE) {
[17:29:08.551]     }
[17:29:08.551]     else {
[17:29:08.551]         if (TRUE) {
[17:29:08.551]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:08.551]                 open = "w")
[17:29:08.551]         }
[17:29:08.551]         else {
[17:29:08.551]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:08.551]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:08.551]         }
[17:29:08.551]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:08.551]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:08.551]             base::sink(type = "output", split = FALSE)
[17:29:08.551]             base::close(...future.stdout)
[17:29:08.551]         }, add = TRUE)
[17:29:08.551]     }
[17:29:08.551]     ...future.frame <- base::sys.nframe()
[17:29:08.551]     ...future.conditions <- base::list()
[17:29:08.551]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:08.551]     if (FALSE) {
[17:29:08.551]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:08.551]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:08.551]     }
[17:29:08.551]     ...future.result <- base::tryCatch({
[17:29:08.551]         base::withCallingHandlers({
[17:29:08.551]             ...future.value <- base::withVisible(base::local({
[17:29:08.551]                 ...future.makeSendCondition <- base::local({
[17:29:08.551]                   sendCondition <- NULL
[17:29:08.551]                   function(frame = 1L) {
[17:29:08.551]                     if (is.function(sendCondition)) 
[17:29:08.551]                       return(sendCondition)
[17:29:08.551]                     ns <- getNamespace("parallel")
[17:29:08.551]                     if (exists("sendData", mode = "function", 
[17:29:08.551]                       envir = ns)) {
[17:29:08.551]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:08.551]                         envir = ns)
[17:29:08.551]                       envir <- sys.frame(frame)
[17:29:08.551]                       master <- NULL
[17:29:08.551]                       while (!identical(envir, .GlobalEnv) && 
[17:29:08.551]                         !identical(envir, emptyenv())) {
[17:29:08.551]                         if (exists("master", mode = "list", envir = envir, 
[17:29:08.551]                           inherits = FALSE)) {
[17:29:08.551]                           master <- get("master", mode = "list", 
[17:29:08.551]                             envir = envir, inherits = FALSE)
[17:29:08.551]                           if (inherits(master, c("SOCKnode", 
[17:29:08.551]                             "SOCK0node"))) {
[17:29:08.551]                             sendCondition <<- function(cond) {
[17:29:08.551]                               data <- list(type = "VALUE", value = cond, 
[17:29:08.551]                                 success = TRUE)
[17:29:08.551]                               parallel_sendData(master, data)
[17:29:08.551]                             }
[17:29:08.551]                             return(sendCondition)
[17:29:08.551]                           }
[17:29:08.551]                         }
[17:29:08.551]                         frame <- frame + 1L
[17:29:08.551]                         envir <- sys.frame(frame)
[17:29:08.551]                       }
[17:29:08.551]                     }
[17:29:08.551]                     sendCondition <<- function(cond) NULL
[17:29:08.551]                   }
[17:29:08.551]                 })
[17:29:08.551]                 withCallingHandlers({
[17:29:08.551]                   list(a = 1, b = 42L, c = stop("Nah!"))
[17:29:08.551]                 }, immediateCondition = function(cond) {
[17:29:08.551]                   sendCondition <- ...future.makeSendCondition()
[17:29:08.551]                   sendCondition(cond)
[17:29:08.551]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:08.551]                   {
[17:29:08.551]                     inherits <- base::inherits
[17:29:08.551]                     invokeRestart <- base::invokeRestart
[17:29:08.551]                     is.null <- base::is.null
[17:29:08.551]                     muffled <- FALSE
[17:29:08.551]                     if (inherits(cond, "message")) {
[17:29:08.551]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:08.551]                       if (muffled) 
[17:29:08.551]                         invokeRestart("muffleMessage")
[17:29:08.551]                     }
[17:29:08.551]                     else if (inherits(cond, "warning")) {
[17:29:08.551]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:08.551]                       if (muffled) 
[17:29:08.551]                         invokeRestart("muffleWarning")
[17:29:08.551]                     }
[17:29:08.551]                     else if (inherits(cond, "condition")) {
[17:29:08.551]                       if (!is.null(pattern)) {
[17:29:08.551]                         computeRestarts <- base::computeRestarts
[17:29:08.551]                         grepl <- base::grepl
[17:29:08.551]                         restarts <- computeRestarts(cond)
[17:29:08.551]                         for (restart in restarts) {
[17:29:08.551]                           name <- restart$name
[17:29:08.551]                           if (is.null(name)) 
[17:29:08.551]                             next
[17:29:08.551]                           if (!grepl(pattern, name)) 
[17:29:08.551]                             next
[17:29:08.551]                           invokeRestart(restart)
[17:29:08.551]                           muffled <- TRUE
[17:29:08.551]                           break
[17:29:08.551]                         }
[17:29:08.551]                       }
[17:29:08.551]                     }
[17:29:08.551]                     invisible(muffled)
[17:29:08.551]                   }
[17:29:08.551]                   muffleCondition(cond)
[17:29:08.551]                 })
[17:29:08.551]             }))
[17:29:08.551]             future::FutureResult(value = ...future.value$value, 
[17:29:08.551]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:08.551]                   ...future.rng), globalenv = if (FALSE) 
[17:29:08.551]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:08.551]                     ...future.globalenv.names))
[17:29:08.551]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:08.551]         }, condition = base::local({
[17:29:08.551]             c <- base::c
[17:29:08.551]             inherits <- base::inherits
[17:29:08.551]             invokeRestart <- base::invokeRestart
[17:29:08.551]             length <- base::length
[17:29:08.551]             list <- base::list
[17:29:08.551]             seq.int <- base::seq.int
[17:29:08.551]             signalCondition <- base::signalCondition
[17:29:08.551]             sys.calls <- base::sys.calls
[17:29:08.551]             `[[` <- base::`[[`
[17:29:08.551]             `+` <- base::`+`
[17:29:08.551]             `<<-` <- base::`<<-`
[17:29:08.551]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:08.551]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:08.551]                   3L)]
[17:29:08.551]             }
[17:29:08.551]             function(cond) {
[17:29:08.551]                 is_error <- inherits(cond, "error")
[17:29:08.551]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:08.551]                   NULL)
[17:29:08.551]                 if (is_error) {
[17:29:08.551]                   sessionInformation <- function() {
[17:29:08.551]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:08.551]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:08.551]                       search = base::search(), system = base::Sys.info())
[17:29:08.551]                   }
[17:29:08.551]                   ...future.conditions[[length(...future.conditions) + 
[17:29:08.551]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:08.551]                     cond$call), session = sessionInformation(), 
[17:29:08.551]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:08.551]                   signalCondition(cond)
[17:29:08.551]                 }
[17:29:08.551]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:08.551]                 "immediateCondition"))) {
[17:29:08.551]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:08.551]                   ...future.conditions[[length(...future.conditions) + 
[17:29:08.551]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:08.551]                   if (TRUE && !signal) {
[17:29:08.551]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:08.551]                     {
[17:29:08.551]                       inherits <- base::inherits
[17:29:08.551]                       invokeRestart <- base::invokeRestart
[17:29:08.551]                       is.null <- base::is.null
[17:29:08.551]                       muffled <- FALSE
[17:29:08.551]                       if (inherits(cond, "message")) {
[17:29:08.551]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:08.551]                         if (muffled) 
[17:29:08.551]                           invokeRestart("muffleMessage")
[17:29:08.551]                       }
[17:29:08.551]                       else if (inherits(cond, "warning")) {
[17:29:08.551]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:08.551]                         if (muffled) 
[17:29:08.551]                           invokeRestart("muffleWarning")
[17:29:08.551]                       }
[17:29:08.551]                       else if (inherits(cond, "condition")) {
[17:29:08.551]                         if (!is.null(pattern)) {
[17:29:08.551]                           computeRestarts <- base::computeRestarts
[17:29:08.551]                           grepl <- base::grepl
[17:29:08.551]                           restarts <- computeRestarts(cond)
[17:29:08.551]                           for (restart in restarts) {
[17:29:08.551]                             name <- restart$name
[17:29:08.551]                             if (is.null(name)) 
[17:29:08.551]                               next
[17:29:08.551]                             if (!grepl(pattern, name)) 
[17:29:08.551]                               next
[17:29:08.551]                             invokeRestart(restart)
[17:29:08.551]                             muffled <- TRUE
[17:29:08.551]                             break
[17:29:08.551]                           }
[17:29:08.551]                         }
[17:29:08.551]                       }
[17:29:08.551]                       invisible(muffled)
[17:29:08.551]                     }
[17:29:08.551]                     muffleCondition(cond, pattern = "^muffle")
[17:29:08.551]                   }
[17:29:08.551]                 }
[17:29:08.551]                 else {
[17:29:08.551]                   if (TRUE) {
[17:29:08.551]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:08.551]                     {
[17:29:08.551]                       inherits <- base::inherits
[17:29:08.551]                       invokeRestart <- base::invokeRestart
[17:29:08.551]                       is.null <- base::is.null
[17:29:08.551]                       muffled <- FALSE
[17:29:08.551]                       if (inherits(cond, "message")) {
[17:29:08.551]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:08.551]                         if (muffled) 
[17:29:08.551]                           invokeRestart("muffleMessage")
[17:29:08.551]                       }
[17:29:08.551]                       else if (inherits(cond, "warning")) {
[17:29:08.551]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:08.551]                         if (muffled) 
[17:29:08.551]                           invokeRestart("muffleWarning")
[17:29:08.551]                       }
[17:29:08.551]                       else if (inherits(cond, "condition")) {
[17:29:08.551]                         if (!is.null(pattern)) {
[17:29:08.551]                           computeRestarts <- base::computeRestarts
[17:29:08.551]                           grepl <- base::grepl
[17:29:08.551]                           restarts <- computeRestarts(cond)
[17:29:08.551]                           for (restart in restarts) {
[17:29:08.551]                             name <- restart$name
[17:29:08.551]                             if (is.null(name)) 
[17:29:08.551]                               next
[17:29:08.551]                             if (!grepl(pattern, name)) 
[17:29:08.551]                               next
[17:29:08.551]                             invokeRestart(restart)
[17:29:08.551]                             muffled <- TRUE
[17:29:08.551]                             break
[17:29:08.551]                           }
[17:29:08.551]                         }
[17:29:08.551]                       }
[17:29:08.551]                       invisible(muffled)
[17:29:08.551]                     }
[17:29:08.551]                     muffleCondition(cond, pattern = "^muffle")
[17:29:08.551]                   }
[17:29:08.551]                 }
[17:29:08.551]             }
[17:29:08.551]         }))
[17:29:08.551]     }, error = function(ex) {
[17:29:08.551]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:08.551]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:08.551]                 ...future.rng), started = ...future.startTime, 
[17:29:08.551]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:08.551]             version = "1.8"), class = "FutureResult")
[17:29:08.551]     }, finally = {
[17:29:08.551]         if (!identical(...future.workdir, getwd())) 
[17:29:08.551]             setwd(...future.workdir)
[17:29:08.551]         {
[17:29:08.551]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:08.551]                 ...future.oldOptions$nwarnings <- NULL
[17:29:08.551]             }
[17:29:08.551]             base::options(...future.oldOptions)
[17:29:08.551]             if (.Platform$OS.type == "windows") {
[17:29:08.551]                 old_names <- names(...future.oldEnvVars)
[17:29:08.551]                 envs <- base::Sys.getenv()
[17:29:08.551]                 names <- names(envs)
[17:29:08.551]                 common <- intersect(names, old_names)
[17:29:08.551]                 added <- setdiff(names, old_names)
[17:29:08.551]                 removed <- setdiff(old_names, names)
[17:29:08.551]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:08.551]                   envs[common]]
[17:29:08.551]                 NAMES <- toupper(changed)
[17:29:08.551]                 args <- list()
[17:29:08.551]                 for (kk in seq_along(NAMES)) {
[17:29:08.551]                   name <- changed[[kk]]
[17:29:08.551]                   NAME <- NAMES[[kk]]
[17:29:08.551]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:08.551]                     next
[17:29:08.551]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:08.551]                 }
[17:29:08.551]                 NAMES <- toupper(added)
[17:29:08.551]                 for (kk in seq_along(NAMES)) {
[17:29:08.551]                   name <- added[[kk]]
[17:29:08.551]                   NAME <- NAMES[[kk]]
[17:29:08.551]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:08.551]                     next
[17:29:08.551]                   args[[name]] <- ""
[17:29:08.551]                 }
[17:29:08.551]                 NAMES <- toupper(removed)
[17:29:08.551]                 for (kk in seq_along(NAMES)) {
[17:29:08.551]                   name <- removed[[kk]]
[17:29:08.551]                   NAME <- NAMES[[kk]]
[17:29:08.551]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:08.551]                     next
[17:29:08.551]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:08.551]                 }
[17:29:08.551]                 if (length(args) > 0) 
[17:29:08.551]                   base::do.call(base::Sys.setenv, args = args)
[17:29:08.551]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:08.551]             }
[17:29:08.551]             else {
[17:29:08.551]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:08.551]             }
[17:29:08.551]             {
[17:29:08.551]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:08.551]                   0L) {
[17:29:08.551]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:08.551]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:08.551]                   base::options(opts)
[17:29:08.551]                 }
[17:29:08.551]                 {
[17:29:08.551]                   {
[17:29:08.551]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:08.551]                     NULL
[17:29:08.551]                   }
[17:29:08.551]                   options(future.plan = NULL)
[17:29:08.551]                   if (is.na(NA_character_)) 
[17:29:08.551]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:08.551]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:08.551]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:08.551]                     .init = FALSE)
[17:29:08.551]                 }
[17:29:08.551]             }
[17:29:08.551]         }
[17:29:08.551]     })
[17:29:08.551]     if (TRUE) {
[17:29:08.551]         base::sink(type = "output", split = FALSE)
[17:29:08.551]         if (TRUE) {
[17:29:08.551]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:08.551]         }
[17:29:08.551]         else {
[17:29:08.551]             ...future.result["stdout"] <- base::list(NULL)
[17:29:08.551]         }
[17:29:08.551]         base::close(...future.stdout)
[17:29:08.551]         ...future.stdout <- NULL
[17:29:08.551]     }
[17:29:08.551]     ...future.result$conditions <- ...future.conditions
[17:29:08.551]     ...future.result$finished <- base::Sys.time()
[17:29:08.551]     ...future.result
[17:29:08.551] }
[17:29:08.561] MultisessionFuture started
[17:29:08.562] - Launch lazy future ... done
[17:29:08.562] run() for 'MultisessionFuture' ... done
[17:29:08.578] receiveMessageFromWorker() for ClusterFuture ...
[17:29:08.578] - Validating connection of MultisessionFuture
[17:29:08.580] - received message: FutureResult
[17:29:08.580] - Received FutureResult
[17:29:08.581] - Erased future from FutureRegistry
[17:29:08.581] result() for ClusterFuture ...
[17:29:08.581] - result already collected: FutureResult
[17:29:08.582] result() for ClusterFuture ... done
[17:29:08.582] signalConditions() ...
[17:29:08.582]  - include = 'immediateCondition'
[17:29:08.583]  - exclude = 
[17:29:08.583]  - resignal = FALSE
[17:29:08.584]  - Number of conditions: 1
[17:29:08.584] signalConditions() ... done
[17:29:08.584] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:08.585] A MultisessionFuture was resolved (result was not collected)
[17:29:08.585] getGlobalsAndPackages() ...
[17:29:08.585] Searching for globals...
[17:29:08.587] - globals found: [2] 'list', 'stop'
[17:29:08.588] Searching for globals ... DONE
[17:29:08.588] Resolving globals: FALSE
[17:29:08.589] 
[17:29:08.590] 
[17:29:08.590] getGlobalsAndPackages() ... DONE
[17:29:08.591] run() for 'Future' ...
[17:29:08.591] - state: 'created'
[17:29:08.592] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:08.624] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:08.625] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:08.625]   - Field: 'node'
[17:29:08.626]   - Field: 'label'
[17:29:08.626]   - Field: 'local'
[17:29:08.626]   - Field: 'owner'
[17:29:08.627]   - Field: 'envir'
[17:29:08.627]   - Field: 'workers'
[17:29:08.627]   - Field: 'packages'
[17:29:08.628]   - Field: 'gc'
[17:29:08.628]   - Field: 'conditions'
[17:29:08.628]   - Field: 'persistent'
[17:29:08.629]   - Field: 'expr'
[17:29:08.629]   - Field: 'uuid'
[17:29:08.629]   - Field: 'seed'
[17:29:08.630]   - Field: 'version'
[17:29:08.630]   - Field: 'result'
[17:29:08.630]   - Field: 'asynchronous'
[17:29:08.631]   - Field: 'calls'
[17:29:08.631]   - Field: 'globals'
[17:29:08.631]   - Field: 'stdout'
[17:29:08.632]   - Field: 'earlySignal'
[17:29:08.632]   - Field: 'lazy'
[17:29:08.632]   - Field: 'state'
[17:29:08.633] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:08.633] - Launch lazy future ...
[17:29:08.634] Packages needed by the future expression (n = 0): <none>
[17:29:08.634] Packages needed by future strategies (n = 0): <none>
[17:29:08.635] {
[17:29:08.635]     {
[17:29:08.635]         {
[17:29:08.635]             ...future.startTime <- base::Sys.time()
[17:29:08.635]             {
[17:29:08.635]                 {
[17:29:08.635]                   {
[17:29:08.635]                     {
[17:29:08.635]                       base::local({
[17:29:08.635]                         has_future <- base::requireNamespace("future", 
[17:29:08.635]                           quietly = TRUE)
[17:29:08.635]                         if (has_future) {
[17:29:08.635]                           ns <- base::getNamespace("future")
[17:29:08.635]                           version <- ns[[".package"]][["version"]]
[17:29:08.635]                           if (is.null(version)) 
[17:29:08.635]                             version <- utils::packageVersion("future")
[17:29:08.635]                         }
[17:29:08.635]                         else {
[17:29:08.635]                           version <- NULL
[17:29:08.635]                         }
[17:29:08.635]                         if (!has_future || version < "1.8.0") {
[17:29:08.635]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:08.635]                             "", base::R.version$version.string), 
[17:29:08.635]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:08.635]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:08.635]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:08.635]                               "release", "version")], collapse = " "), 
[17:29:08.635]                             hostname = base::Sys.info()[["nodename"]])
[17:29:08.635]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:08.635]                             info)
[17:29:08.635]                           info <- base::paste(info, collapse = "; ")
[17:29:08.635]                           if (!has_future) {
[17:29:08.635]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:08.635]                               info)
[17:29:08.635]                           }
[17:29:08.635]                           else {
[17:29:08.635]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:08.635]                               info, version)
[17:29:08.635]                           }
[17:29:08.635]                           base::stop(msg)
[17:29:08.635]                         }
[17:29:08.635]                       })
[17:29:08.635]                     }
[17:29:08.635]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:08.635]                     base::options(mc.cores = 1L)
[17:29:08.635]                   }
[17:29:08.635]                   ...future.strategy.old <- future::plan("list")
[17:29:08.635]                   options(future.plan = NULL)
[17:29:08.635]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:08.635]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:08.635]                 }
[17:29:08.635]                 ...future.workdir <- getwd()
[17:29:08.635]             }
[17:29:08.635]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:08.635]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:08.635]         }
[17:29:08.635]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:08.635]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:08.635]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:08.635]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:08.635]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:08.635]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:08.635]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:08.635]             base::names(...future.oldOptions))
[17:29:08.635]     }
[17:29:08.635]     if (FALSE) {
[17:29:08.635]     }
[17:29:08.635]     else {
[17:29:08.635]         if (TRUE) {
[17:29:08.635]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:08.635]                 open = "w")
[17:29:08.635]         }
[17:29:08.635]         else {
[17:29:08.635]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:08.635]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:08.635]         }
[17:29:08.635]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:08.635]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:08.635]             base::sink(type = "output", split = FALSE)
[17:29:08.635]             base::close(...future.stdout)
[17:29:08.635]         }, add = TRUE)
[17:29:08.635]     }
[17:29:08.635]     ...future.frame <- base::sys.nframe()
[17:29:08.635]     ...future.conditions <- base::list()
[17:29:08.635]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:08.635]     if (FALSE) {
[17:29:08.635]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:08.635]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:08.635]     }
[17:29:08.635]     ...future.result <- base::tryCatch({
[17:29:08.635]         base::withCallingHandlers({
[17:29:08.635]             ...future.value <- base::withVisible(base::local({
[17:29:08.635]                 ...future.makeSendCondition <- base::local({
[17:29:08.635]                   sendCondition <- NULL
[17:29:08.635]                   function(frame = 1L) {
[17:29:08.635]                     if (is.function(sendCondition)) 
[17:29:08.635]                       return(sendCondition)
[17:29:08.635]                     ns <- getNamespace("parallel")
[17:29:08.635]                     if (exists("sendData", mode = "function", 
[17:29:08.635]                       envir = ns)) {
[17:29:08.635]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:08.635]                         envir = ns)
[17:29:08.635]                       envir <- sys.frame(frame)
[17:29:08.635]                       master <- NULL
[17:29:08.635]                       while (!identical(envir, .GlobalEnv) && 
[17:29:08.635]                         !identical(envir, emptyenv())) {
[17:29:08.635]                         if (exists("master", mode = "list", envir = envir, 
[17:29:08.635]                           inherits = FALSE)) {
[17:29:08.635]                           master <- get("master", mode = "list", 
[17:29:08.635]                             envir = envir, inherits = FALSE)
[17:29:08.635]                           if (inherits(master, c("SOCKnode", 
[17:29:08.635]                             "SOCK0node"))) {
[17:29:08.635]                             sendCondition <<- function(cond) {
[17:29:08.635]                               data <- list(type = "VALUE", value = cond, 
[17:29:08.635]                                 success = TRUE)
[17:29:08.635]                               parallel_sendData(master, data)
[17:29:08.635]                             }
[17:29:08.635]                             return(sendCondition)
[17:29:08.635]                           }
[17:29:08.635]                         }
[17:29:08.635]                         frame <- frame + 1L
[17:29:08.635]                         envir <- sys.frame(frame)
[17:29:08.635]                       }
[17:29:08.635]                     }
[17:29:08.635]                     sendCondition <<- function(cond) NULL
[17:29:08.635]                   }
[17:29:08.635]                 })
[17:29:08.635]                 withCallingHandlers({
[17:29:08.635]                   list(a = 1, b = 42L, c = stop("Nah!"))
[17:29:08.635]                 }, immediateCondition = function(cond) {
[17:29:08.635]                   sendCondition <- ...future.makeSendCondition()
[17:29:08.635]                   sendCondition(cond)
[17:29:08.635]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:08.635]                   {
[17:29:08.635]                     inherits <- base::inherits
[17:29:08.635]                     invokeRestart <- base::invokeRestart
[17:29:08.635]                     is.null <- base::is.null
[17:29:08.635]                     muffled <- FALSE
[17:29:08.635]                     if (inherits(cond, "message")) {
[17:29:08.635]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:08.635]                       if (muffled) 
[17:29:08.635]                         invokeRestart("muffleMessage")
[17:29:08.635]                     }
[17:29:08.635]                     else if (inherits(cond, "warning")) {
[17:29:08.635]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:08.635]                       if (muffled) 
[17:29:08.635]                         invokeRestart("muffleWarning")
[17:29:08.635]                     }
[17:29:08.635]                     else if (inherits(cond, "condition")) {
[17:29:08.635]                       if (!is.null(pattern)) {
[17:29:08.635]                         computeRestarts <- base::computeRestarts
[17:29:08.635]                         grepl <- base::grepl
[17:29:08.635]                         restarts <- computeRestarts(cond)
[17:29:08.635]                         for (restart in restarts) {
[17:29:08.635]                           name <- restart$name
[17:29:08.635]                           if (is.null(name)) 
[17:29:08.635]                             next
[17:29:08.635]                           if (!grepl(pattern, name)) 
[17:29:08.635]                             next
[17:29:08.635]                           invokeRestart(restart)
[17:29:08.635]                           muffled <- TRUE
[17:29:08.635]                           break
[17:29:08.635]                         }
[17:29:08.635]                       }
[17:29:08.635]                     }
[17:29:08.635]                     invisible(muffled)
[17:29:08.635]                   }
[17:29:08.635]                   muffleCondition(cond)
[17:29:08.635]                 })
[17:29:08.635]             }))
[17:29:08.635]             future::FutureResult(value = ...future.value$value, 
[17:29:08.635]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:08.635]                   ...future.rng), globalenv = if (FALSE) 
[17:29:08.635]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:08.635]                     ...future.globalenv.names))
[17:29:08.635]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:08.635]         }, condition = base::local({
[17:29:08.635]             c <- base::c
[17:29:08.635]             inherits <- base::inherits
[17:29:08.635]             invokeRestart <- base::invokeRestart
[17:29:08.635]             length <- base::length
[17:29:08.635]             list <- base::list
[17:29:08.635]             seq.int <- base::seq.int
[17:29:08.635]             signalCondition <- base::signalCondition
[17:29:08.635]             sys.calls <- base::sys.calls
[17:29:08.635]             `[[` <- base::`[[`
[17:29:08.635]             `+` <- base::`+`
[17:29:08.635]             `<<-` <- base::`<<-`
[17:29:08.635]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:08.635]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:08.635]                   3L)]
[17:29:08.635]             }
[17:29:08.635]             function(cond) {
[17:29:08.635]                 is_error <- inherits(cond, "error")
[17:29:08.635]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:08.635]                   NULL)
[17:29:08.635]                 if (is_error) {
[17:29:08.635]                   sessionInformation <- function() {
[17:29:08.635]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:08.635]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:08.635]                       search = base::search(), system = base::Sys.info())
[17:29:08.635]                   }
[17:29:08.635]                   ...future.conditions[[length(...future.conditions) + 
[17:29:08.635]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:08.635]                     cond$call), session = sessionInformation(), 
[17:29:08.635]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:08.635]                   signalCondition(cond)
[17:29:08.635]                 }
[17:29:08.635]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:08.635]                 "immediateCondition"))) {
[17:29:08.635]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:08.635]                   ...future.conditions[[length(...future.conditions) + 
[17:29:08.635]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:08.635]                   if (TRUE && !signal) {
[17:29:08.635]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:08.635]                     {
[17:29:08.635]                       inherits <- base::inherits
[17:29:08.635]                       invokeRestart <- base::invokeRestart
[17:29:08.635]                       is.null <- base::is.null
[17:29:08.635]                       muffled <- FALSE
[17:29:08.635]                       if (inherits(cond, "message")) {
[17:29:08.635]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:08.635]                         if (muffled) 
[17:29:08.635]                           invokeRestart("muffleMessage")
[17:29:08.635]                       }
[17:29:08.635]                       else if (inherits(cond, "warning")) {
[17:29:08.635]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:08.635]                         if (muffled) 
[17:29:08.635]                           invokeRestart("muffleWarning")
[17:29:08.635]                       }
[17:29:08.635]                       else if (inherits(cond, "condition")) {
[17:29:08.635]                         if (!is.null(pattern)) {
[17:29:08.635]                           computeRestarts <- base::computeRestarts
[17:29:08.635]                           grepl <- base::grepl
[17:29:08.635]                           restarts <- computeRestarts(cond)
[17:29:08.635]                           for (restart in restarts) {
[17:29:08.635]                             name <- restart$name
[17:29:08.635]                             if (is.null(name)) 
[17:29:08.635]                               next
[17:29:08.635]                             if (!grepl(pattern, name)) 
[17:29:08.635]                               next
[17:29:08.635]                             invokeRestart(restart)
[17:29:08.635]                             muffled <- TRUE
[17:29:08.635]                             break
[17:29:08.635]                           }
[17:29:08.635]                         }
[17:29:08.635]                       }
[17:29:08.635]                       invisible(muffled)
[17:29:08.635]                     }
[17:29:08.635]                     muffleCondition(cond, pattern = "^muffle")
[17:29:08.635]                   }
[17:29:08.635]                 }
[17:29:08.635]                 else {
[17:29:08.635]                   if (TRUE) {
[17:29:08.635]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:08.635]                     {
[17:29:08.635]                       inherits <- base::inherits
[17:29:08.635]                       invokeRestart <- base::invokeRestart
[17:29:08.635]                       is.null <- base::is.null
[17:29:08.635]                       muffled <- FALSE
[17:29:08.635]                       if (inherits(cond, "message")) {
[17:29:08.635]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:08.635]                         if (muffled) 
[17:29:08.635]                           invokeRestart("muffleMessage")
[17:29:08.635]                       }
[17:29:08.635]                       else if (inherits(cond, "warning")) {
[17:29:08.635]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:08.635]                         if (muffled) 
[17:29:08.635]                           invokeRestart("muffleWarning")
[17:29:08.635]                       }
[17:29:08.635]                       else if (inherits(cond, "condition")) {
[17:29:08.635]                         if (!is.null(pattern)) {
[17:29:08.635]                           computeRestarts <- base::computeRestarts
[17:29:08.635]                           grepl <- base::grepl
[17:29:08.635]                           restarts <- computeRestarts(cond)
[17:29:08.635]                           for (restart in restarts) {
[17:29:08.635]                             name <- restart$name
[17:29:08.635]                             if (is.null(name)) 
[17:29:08.635]                               next
[17:29:08.635]                             if (!grepl(pattern, name)) 
[17:29:08.635]                               next
[17:29:08.635]                             invokeRestart(restart)
[17:29:08.635]                             muffled <- TRUE
[17:29:08.635]                             break
[17:29:08.635]                           }
[17:29:08.635]                         }
[17:29:08.635]                       }
[17:29:08.635]                       invisible(muffled)
[17:29:08.635]                     }
[17:29:08.635]                     muffleCondition(cond, pattern = "^muffle")
[17:29:08.635]                   }
[17:29:08.635]                 }
[17:29:08.635]             }
[17:29:08.635]         }))
[17:29:08.635]     }, error = function(ex) {
[17:29:08.635]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:08.635]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:08.635]                 ...future.rng), started = ...future.startTime, 
[17:29:08.635]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:08.635]             version = "1.8"), class = "FutureResult")
[17:29:08.635]     }, finally = {
[17:29:08.635]         if (!identical(...future.workdir, getwd())) 
[17:29:08.635]             setwd(...future.workdir)
[17:29:08.635]         {
[17:29:08.635]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:08.635]                 ...future.oldOptions$nwarnings <- NULL
[17:29:08.635]             }
[17:29:08.635]             base::options(...future.oldOptions)
[17:29:08.635]             if (.Platform$OS.type == "windows") {
[17:29:08.635]                 old_names <- names(...future.oldEnvVars)
[17:29:08.635]                 envs <- base::Sys.getenv()
[17:29:08.635]                 names <- names(envs)
[17:29:08.635]                 common <- intersect(names, old_names)
[17:29:08.635]                 added <- setdiff(names, old_names)
[17:29:08.635]                 removed <- setdiff(old_names, names)
[17:29:08.635]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:08.635]                   envs[common]]
[17:29:08.635]                 NAMES <- toupper(changed)
[17:29:08.635]                 args <- list()
[17:29:08.635]                 for (kk in seq_along(NAMES)) {
[17:29:08.635]                   name <- changed[[kk]]
[17:29:08.635]                   NAME <- NAMES[[kk]]
[17:29:08.635]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:08.635]                     next
[17:29:08.635]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:08.635]                 }
[17:29:08.635]                 NAMES <- toupper(added)
[17:29:08.635]                 for (kk in seq_along(NAMES)) {
[17:29:08.635]                   name <- added[[kk]]
[17:29:08.635]                   NAME <- NAMES[[kk]]
[17:29:08.635]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:08.635]                     next
[17:29:08.635]                   args[[name]] <- ""
[17:29:08.635]                 }
[17:29:08.635]                 NAMES <- toupper(removed)
[17:29:08.635]                 for (kk in seq_along(NAMES)) {
[17:29:08.635]                   name <- removed[[kk]]
[17:29:08.635]                   NAME <- NAMES[[kk]]
[17:29:08.635]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:08.635]                     next
[17:29:08.635]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:08.635]                 }
[17:29:08.635]                 if (length(args) > 0) 
[17:29:08.635]                   base::do.call(base::Sys.setenv, args = args)
[17:29:08.635]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:08.635]             }
[17:29:08.635]             else {
[17:29:08.635]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:08.635]             }
[17:29:08.635]             {
[17:29:08.635]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:08.635]                   0L) {
[17:29:08.635]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:08.635]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:08.635]                   base::options(opts)
[17:29:08.635]                 }
[17:29:08.635]                 {
[17:29:08.635]                   {
[17:29:08.635]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:08.635]                     NULL
[17:29:08.635]                   }
[17:29:08.635]                   options(future.plan = NULL)
[17:29:08.635]                   if (is.na(NA_character_)) 
[17:29:08.635]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:08.635]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:08.635]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:08.635]                     .init = FALSE)
[17:29:08.635]                 }
[17:29:08.635]             }
[17:29:08.635]         }
[17:29:08.635]     })
[17:29:08.635]     if (TRUE) {
[17:29:08.635]         base::sink(type = "output", split = FALSE)
[17:29:08.635]         if (TRUE) {
[17:29:08.635]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:08.635]         }
[17:29:08.635]         else {
[17:29:08.635]             ...future.result["stdout"] <- base::list(NULL)
[17:29:08.635]         }
[17:29:08.635]         base::close(...future.stdout)
[17:29:08.635]         ...future.stdout <- NULL
[17:29:08.635]     }
[17:29:08.635]     ...future.result$conditions <- ...future.conditions
[17:29:08.635]     ...future.result$finished <- base::Sys.time()
[17:29:08.635]     ...future.result
[17:29:08.635] }
[17:29:08.645] MultisessionFuture started
[17:29:08.646] - Launch lazy future ... done
[17:29:08.646] run() for 'MultisessionFuture' ... done
[17:29:08.675] receiveMessageFromWorker() for ClusterFuture ...
[17:29:08.676] - Validating connection of MultisessionFuture
[17:29:08.677] - received message: FutureResult
[17:29:08.677] - Received FutureResult
[17:29:08.677] - Erased future from FutureRegistry
[17:29:08.678] result() for ClusterFuture ...
[17:29:08.678] - result already collected: FutureResult
[17:29:08.678] result() for ClusterFuture ... done
[17:29:08.679] signalConditions() ...
[17:29:08.679]  - include = 'immediateCondition'
[17:29:08.679]  - exclude = 
[17:29:08.679]  - resignal = FALSE
[17:29:08.680]  - Number of conditions: 1
[17:29:08.680] signalConditions() ... done
[17:29:08.680] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:08.681] A MultisessionFuture was resolved (result was not collected)
- result = FALSE, recursive = FALSE ... DONE
- result = FALSE, recursive = TRUE ...
[17:29:08.681] getGlobalsAndPackages() ...
[17:29:08.682] Searching for globals...
[17:29:08.684] - globals found: [3] '{', 'Sys.sleep', 'list'
[17:29:08.685] Searching for globals ... DONE
[17:29:08.685] Resolving globals: FALSE
[17:29:08.686] 
[17:29:08.686] 
[17:29:08.686] getGlobalsAndPackages() ... DONE
[17:29:08.687] run() for 'Future' ...
[17:29:08.687] - state: 'created'
[17:29:08.688] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:08.715] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:08.716] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:08.716]   - Field: 'node'
[17:29:08.717]   - Field: 'label'
[17:29:08.717]   - Field: 'local'
[17:29:08.717]   - Field: 'owner'
[17:29:08.718]   - Field: 'envir'
[17:29:08.718]   - Field: 'workers'
[17:29:08.719]   - Field: 'packages'
[17:29:08.719]   - Field: 'gc'
[17:29:08.720]   - Field: 'conditions'
[17:29:08.720]   - Field: 'persistent'
[17:29:08.720]   - Field: 'expr'
[17:29:08.721]   - Field: 'uuid'
[17:29:08.721]   - Field: 'seed'
[17:29:08.722]   - Field: 'version'
[17:29:08.722]   - Field: 'result'
[17:29:08.722]   - Field: 'asynchronous'
[17:29:08.723]   - Field: 'calls'
[17:29:08.723]   - Field: 'globals'
[17:29:08.723]   - Field: 'stdout'
[17:29:08.724]   - Field: 'earlySignal'
[17:29:08.724]   - Field: 'lazy'
[17:29:08.724]   - Field: 'state'
[17:29:08.725] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:08.725] - Launch lazy future ...
[17:29:08.726] Packages needed by the future expression (n = 0): <none>
[17:29:08.726] Packages needed by future strategies (n = 0): <none>
[17:29:08.727] {
[17:29:08.727]     {
[17:29:08.727]         {
[17:29:08.727]             ...future.startTime <- base::Sys.time()
[17:29:08.727]             {
[17:29:08.727]                 {
[17:29:08.727]                   {
[17:29:08.727]                     {
[17:29:08.727]                       base::local({
[17:29:08.727]                         has_future <- base::requireNamespace("future", 
[17:29:08.727]                           quietly = TRUE)
[17:29:08.727]                         if (has_future) {
[17:29:08.727]                           ns <- base::getNamespace("future")
[17:29:08.727]                           version <- ns[[".package"]][["version"]]
[17:29:08.727]                           if (is.null(version)) 
[17:29:08.727]                             version <- utils::packageVersion("future")
[17:29:08.727]                         }
[17:29:08.727]                         else {
[17:29:08.727]                           version <- NULL
[17:29:08.727]                         }
[17:29:08.727]                         if (!has_future || version < "1.8.0") {
[17:29:08.727]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:08.727]                             "", base::R.version$version.string), 
[17:29:08.727]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:08.727]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:08.727]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:08.727]                               "release", "version")], collapse = " "), 
[17:29:08.727]                             hostname = base::Sys.info()[["nodename"]])
[17:29:08.727]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:08.727]                             info)
[17:29:08.727]                           info <- base::paste(info, collapse = "; ")
[17:29:08.727]                           if (!has_future) {
[17:29:08.727]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:08.727]                               info)
[17:29:08.727]                           }
[17:29:08.727]                           else {
[17:29:08.727]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:08.727]                               info, version)
[17:29:08.727]                           }
[17:29:08.727]                           base::stop(msg)
[17:29:08.727]                         }
[17:29:08.727]                       })
[17:29:08.727]                     }
[17:29:08.727]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:08.727]                     base::options(mc.cores = 1L)
[17:29:08.727]                   }
[17:29:08.727]                   ...future.strategy.old <- future::plan("list")
[17:29:08.727]                   options(future.plan = NULL)
[17:29:08.727]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:08.727]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:08.727]                 }
[17:29:08.727]                 ...future.workdir <- getwd()
[17:29:08.727]             }
[17:29:08.727]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:08.727]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:08.727]         }
[17:29:08.727]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:08.727]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:08.727]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:08.727]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:08.727]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:08.727]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:08.727]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:08.727]             base::names(...future.oldOptions))
[17:29:08.727]     }
[17:29:08.727]     if (FALSE) {
[17:29:08.727]     }
[17:29:08.727]     else {
[17:29:08.727]         if (TRUE) {
[17:29:08.727]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:08.727]                 open = "w")
[17:29:08.727]         }
[17:29:08.727]         else {
[17:29:08.727]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:08.727]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:08.727]         }
[17:29:08.727]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:08.727]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:08.727]             base::sink(type = "output", split = FALSE)
[17:29:08.727]             base::close(...future.stdout)
[17:29:08.727]         }, add = TRUE)
[17:29:08.727]     }
[17:29:08.727]     ...future.frame <- base::sys.nframe()
[17:29:08.727]     ...future.conditions <- base::list()
[17:29:08.727]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:08.727]     if (FALSE) {
[17:29:08.727]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:08.727]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:08.727]     }
[17:29:08.727]     ...future.result <- base::tryCatch({
[17:29:08.727]         base::withCallingHandlers({
[17:29:08.727]             ...future.value <- base::withVisible(base::local({
[17:29:08.727]                 ...future.makeSendCondition <- base::local({
[17:29:08.727]                   sendCondition <- NULL
[17:29:08.727]                   function(frame = 1L) {
[17:29:08.727]                     if (is.function(sendCondition)) 
[17:29:08.727]                       return(sendCondition)
[17:29:08.727]                     ns <- getNamespace("parallel")
[17:29:08.727]                     if (exists("sendData", mode = "function", 
[17:29:08.727]                       envir = ns)) {
[17:29:08.727]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:08.727]                         envir = ns)
[17:29:08.727]                       envir <- sys.frame(frame)
[17:29:08.727]                       master <- NULL
[17:29:08.727]                       while (!identical(envir, .GlobalEnv) && 
[17:29:08.727]                         !identical(envir, emptyenv())) {
[17:29:08.727]                         if (exists("master", mode = "list", envir = envir, 
[17:29:08.727]                           inherits = FALSE)) {
[17:29:08.727]                           master <- get("master", mode = "list", 
[17:29:08.727]                             envir = envir, inherits = FALSE)
[17:29:08.727]                           if (inherits(master, c("SOCKnode", 
[17:29:08.727]                             "SOCK0node"))) {
[17:29:08.727]                             sendCondition <<- function(cond) {
[17:29:08.727]                               data <- list(type = "VALUE", value = cond, 
[17:29:08.727]                                 success = TRUE)
[17:29:08.727]                               parallel_sendData(master, data)
[17:29:08.727]                             }
[17:29:08.727]                             return(sendCondition)
[17:29:08.727]                           }
[17:29:08.727]                         }
[17:29:08.727]                         frame <- frame + 1L
[17:29:08.727]                         envir <- sys.frame(frame)
[17:29:08.727]                       }
[17:29:08.727]                     }
[17:29:08.727]                     sendCondition <<- function(cond) NULL
[17:29:08.727]                   }
[17:29:08.727]                 })
[17:29:08.727]                 withCallingHandlers({
[17:29:08.727]                   {
[17:29:08.727]                     Sys.sleep(0.5)
[17:29:08.727]                     list(a = 1, b = 42L)
[17:29:08.727]                   }
[17:29:08.727]                 }, immediateCondition = function(cond) {
[17:29:08.727]                   sendCondition <- ...future.makeSendCondition()
[17:29:08.727]                   sendCondition(cond)
[17:29:08.727]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:08.727]                   {
[17:29:08.727]                     inherits <- base::inherits
[17:29:08.727]                     invokeRestart <- base::invokeRestart
[17:29:08.727]                     is.null <- base::is.null
[17:29:08.727]                     muffled <- FALSE
[17:29:08.727]                     if (inherits(cond, "message")) {
[17:29:08.727]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:08.727]                       if (muffled) 
[17:29:08.727]                         invokeRestart("muffleMessage")
[17:29:08.727]                     }
[17:29:08.727]                     else if (inherits(cond, "warning")) {
[17:29:08.727]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:08.727]                       if (muffled) 
[17:29:08.727]                         invokeRestart("muffleWarning")
[17:29:08.727]                     }
[17:29:08.727]                     else if (inherits(cond, "condition")) {
[17:29:08.727]                       if (!is.null(pattern)) {
[17:29:08.727]                         computeRestarts <- base::computeRestarts
[17:29:08.727]                         grepl <- base::grepl
[17:29:08.727]                         restarts <- computeRestarts(cond)
[17:29:08.727]                         for (restart in restarts) {
[17:29:08.727]                           name <- restart$name
[17:29:08.727]                           if (is.null(name)) 
[17:29:08.727]                             next
[17:29:08.727]                           if (!grepl(pattern, name)) 
[17:29:08.727]                             next
[17:29:08.727]                           invokeRestart(restart)
[17:29:08.727]                           muffled <- TRUE
[17:29:08.727]                           break
[17:29:08.727]                         }
[17:29:08.727]                       }
[17:29:08.727]                     }
[17:29:08.727]                     invisible(muffled)
[17:29:08.727]                   }
[17:29:08.727]                   muffleCondition(cond)
[17:29:08.727]                 })
[17:29:08.727]             }))
[17:29:08.727]             future::FutureResult(value = ...future.value$value, 
[17:29:08.727]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:08.727]                   ...future.rng), globalenv = if (FALSE) 
[17:29:08.727]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:08.727]                     ...future.globalenv.names))
[17:29:08.727]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:08.727]         }, condition = base::local({
[17:29:08.727]             c <- base::c
[17:29:08.727]             inherits <- base::inherits
[17:29:08.727]             invokeRestart <- base::invokeRestart
[17:29:08.727]             length <- base::length
[17:29:08.727]             list <- base::list
[17:29:08.727]             seq.int <- base::seq.int
[17:29:08.727]             signalCondition <- base::signalCondition
[17:29:08.727]             sys.calls <- base::sys.calls
[17:29:08.727]             `[[` <- base::`[[`
[17:29:08.727]             `+` <- base::`+`
[17:29:08.727]             `<<-` <- base::`<<-`
[17:29:08.727]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:08.727]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:08.727]                   3L)]
[17:29:08.727]             }
[17:29:08.727]             function(cond) {
[17:29:08.727]                 is_error <- inherits(cond, "error")
[17:29:08.727]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:08.727]                   NULL)
[17:29:08.727]                 if (is_error) {
[17:29:08.727]                   sessionInformation <- function() {
[17:29:08.727]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:08.727]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:08.727]                       search = base::search(), system = base::Sys.info())
[17:29:08.727]                   }
[17:29:08.727]                   ...future.conditions[[length(...future.conditions) + 
[17:29:08.727]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:08.727]                     cond$call), session = sessionInformation(), 
[17:29:08.727]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:08.727]                   signalCondition(cond)
[17:29:08.727]                 }
[17:29:08.727]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:08.727]                 "immediateCondition"))) {
[17:29:08.727]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:08.727]                   ...future.conditions[[length(...future.conditions) + 
[17:29:08.727]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:08.727]                   if (TRUE && !signal) {
[17:29:08.727]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:08.727]                     {
[17:29:08.727]                       inherits <- base::inherits
[17:29:08.727]                       invokeRestart <- base::invokeRestart
[17:29:08.727]                       is.null <- base::is.null
[17:29:08.727]                       muffled <- FALSE
[17:29:08.727]                       if (inherits(cond, "message")) {
[17:29:08.727]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:08.727]                         if (muffled) 
[17:29:08.727]                           invokeRestart("muffleMessage")
[17:29:08.727]                       }
[17:29:08.727]                       else if (inherits(cond, "warning")) {
[17:29:08.727]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:08.727]                         if (muffled) 
[17:29:08.727]                           invokeRestart("muffleWarning")
[17:29:08.727]                       }
[17:29:08.727]                       else if (inherits(cond, "condition")) {
[17:29:08.727]                         if (!is.null(pattern)) {
[17:29:08.727]                           computeRestarts <- base::computeRestarts
[17:29:08.727]                           grepl <- base::grepl
[17:29:08.727]                           restarts <- computeRestarts(cond)
[17:29:08.727]                           for (restart in restarts) {
[17:29:08.727]                             name <- restart$name
[17:29:08.727]                             if (is.null(name)) 
[17:29:08.727]                               next
[17:29:08.727]                             if (!grepl(pattern, name)) 
[17:29:08.727]                               next
[17:29:08.727]                             invokeRestart(restart)
[17:29:08.727]                             muffled <- TRUE
[17:29:08.727]                             break
[17:29:08.727]                           }
[17:29:08.727]                         }
[17:29:08.727]                       }
[17:29:08.727]                       invisible(muffled)
[17:29:08.727]                     }
[17:29:08.727]                     muffleCondition(cond, pattern = "^muffle")
[17:29:08.727]                   }
[17:29:08.727]                 }
[17:29:08.727]                 else {
[17:29:08.727]                   if (TRUE) {
[17:29:08.727]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:08.727]                     {
[17:29:08.727]                       inherits <- base::inherits
[17:29:08.727]                       invokeRestart <- base::invokeRestart
[17:29:08.727]                       is.null <- base::is.null
[17:29:08.727]                       muffled <- FALSE
[17:29:08.727]                       if (inherits(cond, "message")) {
[17:29:08.727]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:08.727]                         if (muffled) 
[17:29:08.727]                           invokeRestart("muffleMessage")
[17:29:08.727]                       }
[17:29:08.727]                       else if (inherits(cond, "warning")) {
[17:29:08.727]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:08.727]                         if (muffled) 
[17:29:08.727]                           invokeRestart("muffleWarning")
[17:29:08.727]                       }
[17:29:08.727]                       else if (inherits(cond, "condition")) {
[17:29:08.727]                         if (!is.null(pattern)) {
[17:29:08.727]                           computeRestarts <- base::computeRestarts
[17:29:08.727]                           grepl <- base::grepl
[17:29:08.727]                           restarts <- computeRestarts(cond)
[17:29:08.727]                           for (restart in restarts) {
[17:29:08.727]                             name <- restart$name
[17:29:08.727]                             if (is.null(name)) 
[17:29:08.727]                               next
[17:29:08.727]                             if (!grepl(pattern, name)) 
[17:29:08.727]                               next
[17:29:08.727]                             invokeRestart(restart)
[17:29:08.727]                             muffled <- TRUE
[17:29:08.727]                             break
[17:29:08.727]                           }
[17:29:08.727]                         }
[17:29:08.727]                       }
[17:29:08.727]                       invisible(muffled)
[17:29:08.727]                     }
[17:29:08.727]                     muffleCondition(cond, pattern = "^muffle")
[17:29:08.727]                   }
[17:29:08.727]                 }
[17:29:08.727]             }
[17:29:08.727]         }))
[17:29:08.727]     }, error = function(ex) {
[17:29:08.727]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:08.727]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:08.727]                 ...future.rng), started = ...future.startTime, 
[17:29:08.727]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:08.727]             version = "1.8"), class = "FutureResult")
[17:29:08.727]     }, finally = {
[17:29:08.727]         if (!identical(...future.workdir, getwd())) 
[17:29:08.727]             setwd(...future.workdir)
[17:29:08.727]         {
[17:29:08.727]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:08.727]                 ...future.oldOptions$nwarnings <- NULL
[17:29:08.727]             }
[17:29:08.727]             base::options(...future.oldOptions)
[17:29:08.727]             if (.Platform$OS.type == "windows") {
[17:29:08.727]                 old_names <- names(...future.oldEnvVars)
[17:29:08.727]                 envs <- base::Sys.getenv()
[17:29:08.727]                 names <- names(envs)
[17:29:08.727]                 common <- intersect(names, old_names)
[17:29:08.727]                 added <- setdiff(names, old_names)
[17:29:08.727]                 removed <- setdiff(old_names, names)
[17:29:08.727]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:08.727]                   envs[common]]
[17:29:08.727]                 NAMES <- toupper(changed)
[17:29:08.727]                 args <- list()
[17:29:08.727]                 for (kk in seq_along(NAMES)) {
[17:29:08.727]                   name <- changed[[kk]]
[17:29:08.727]                   NAME <- NAMES[[kk]]
[17:29:08.727]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:08.727]                     next
[17:29:08.727]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:08.727]                 }
[17:29:08.727]                 NAMES <- toupper(added)
[17:29:08.727]                 for (kk in seq_along(NAMES)) {
[17:29:08.727]                   name <- added[[kk]]
[17:29:08.727]                   NAME <- NAMES[[kk]]
[17:29:08.727]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:08.727]                     next
[17:29:08.727]                   args[[name]] <- ""
[17:29:08.727]                 }
[17:29:08.727]                 NAMES <- toupper(removed)
[17:29:08.727]                 for (kk in seq_along(NAMES)) {
[17:29:08.727]                   name <- removed[[kk]]
[17:29:08.727]                   NAME <- NAMES[[kk]]
[17:29:08.727]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:08.727]                     next
[17:29:08.727]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:08.727]                 }
[17:29:08.727]                 if (length(args) > 0) 
[17:29:08.727]                   base::do.call(base::Sys.setenv, args = args)
[17:29:08.727]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:08.727]             }
[17:29:08.727]             else {
[17:29:08.727]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:08.727]             }
[17:29:08.727]             {
[17:29:08.727]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:08.727]                   0L) {
[17:29:08.727]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:08.727]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:08.727]                   base::options(opts)
[17:29:08.727]                 }
[17:29:08.727]                 {
[17:29:08.727]                   {
[17:29:08.727]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:08.727]                     NULL
[17:29:08.727]                   }
[17:29:08.727]                   options(future.plan = NULL)
[17:29:08.727]                   if (is.na(NA_character_)) 
[17:29:08.727]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:08.727]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:08.727]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:08.727]                     .init = FALSE)
[17:29:08.727]                 }
[17:29:08.727]             }
[17:29:08.727]         }
[17:29:08.727]     })
[17:29:08.727]     if (TRUE) {
[17:29:08.727]         base::sink(type = "output", split = FALSE)
[17:29:08.727]         if (TRUE) {
[17:29:08.727]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:08.727]         }
[17:29:08.727]         else {
[17:29:08.727]             ...future.result["stdout"] <- base::list(NULL)
[17:29:08.727]         }
[17:29:08.727]         base::close(...future.stdout)
[17:29:08.727]         ...future.stdout <- NULL
[17:29:08.727]     }
[17:29:08.727]     ...future.result$conditions <- ...future.conditions
[17:29:08.727]     ...future.result$finished <- base::Sys.time()
[17:29:08.727]     ...future.result
[17:29:08.727] }
[17:29:08.734] MultisessionFuture started
[17:29:08.735] - Launch lazy future ... done
[17:29:08.735] run() for 'MultisessionFuture' ... done
[17:29:09.253] receiveMessageFromWorker() for ClusterFuture ...
[17:29:09.254] - Validating connection of MultisessionFuture
[17:29:09.254] - received message: FutureResult
[17:29:09.255] - Received FutureResult
[17:29:09.255] - Erased future from FutureRegistry
[17:29:09.255] result() for ClusterFuture ...
[17:29:09.255] - result already collected: FutureResult
[17:29:09.255] result() for ClusterFuture ... done
[17:29:09.256] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:09.256] A MultisessionFuture was resolved (result was not collected)
[17:29:09.256] getGlobalsAndPackages() ...
[17:29:09.256] Searching for globals...
[17:29:09.258] - globals found: [3] '{', 'Sys.sleep', 'list'
[17:29:09.259] Searching for globals ... DONE
[17:29:09.259] Resolving globals: FALSE
[17:29:09.259] 
[17:29:09.260] 
[17:29:09.260] getGlobalsAndPackages() ... DONE
[17:29:09.260] run() for 'Future' ...
[17:29:09.260] - state: 'created'
[17:29:09.261] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:09.283] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:09.283] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:09.284]   - Field: 'node'
[17:29:09.284]   - Field: 'label'
[17:29:09.285]   - Field: 'local'
[17:29:09.285]   - Field: 'owner'
[17:29:09.285]   - Field: 'envir'
[17:29:09.286]   - Field: 'workers'
[17:29:09.286]   - Field: 'packages'
[17:29:09.286]   - Field: 'gc'
[17:29:09.287]   - Field: 'conditions'
[17:29:09.287]   - Field: 'persistent'
[17:29:09.287]   - Field: 'expr'
[17:29:09.287]   - Field: 'uuid'
[17:29:09.288]   - Field: 'seed'
[17:29:09.288]   - Field: 'version'
[17:29:09.288]   - Field: 'result'
[17:29:09.289]   - Field: 'asynchronous'
[17:29:09.289]   - Field: 'calls'
[17:29:09.289]   - Field: 'globals'
[17:29:09.290]   - Field: 'stdout'
[17:29:09.290]   - Field: 'earlySignal'
[17:29:09.290]   - Field: 'lazy'
[17:29:09.291]   - Field: 'state'
[17:29:09.291] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:09.291] - Launch lazy future ...
[17:29:09.292] Packages needed by the future expression (n = 0): <none>
[17:29:09.292] Packages needed by future strategies (n = 0): <none>
[17:29:09.293] {
[17:29:09.293]     {
[17:29:09.293]         {
[17:29:09.293]             ...future.startTime <- base::Sys.time()
[17:29:09.293]             {
[17:29:09.293]                 {
[17:29:09.293]                   {
[17:29:09.293]                     {
[17:29:09.293]                       base::local({
[17:29:09.293]                         has_future <- base::requireNamespace("future", 
[17:29:09.293]                           quietly = TRUE)
[17:29:09.293]                         if (has_future) {
[17:29:09.293]                           ns <- base::getNamespace("future")
[17:29:09.293]                           version <- ns[[".package"]][["version"]]
[17:29:09.293]                           if (is.null(version)) 
[17:29:09.293]                             version <- utils::packageVersion("future")
[17:29:09.293]                         }
[17:29:09.293]                         else {
[17:29:09.293]                           version <- NULL
[17:29:09.293]                         }
[17:29:09.293]                         if (!has_future || version < "1.8.0") {
[17:29:09.293]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:09.293]                             "", base::R.version$version.string), 
[17:29:09.293]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:09.293]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:09.293]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:09.293]                               "release", "version")], collapse = " "), 
[17:29:09.293]                             hostname = base::Sys.info()[["nodename"]])
[17:29:09.293]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:09.293]                             info)
[17:29:09.293]                           info <- base::paste(info, collapse = "; ")
[17:29:09.293]                           if (!has_future) {
[17:29:09.293]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:09.293]                               info)
[17:29:09.293]                           }
[17:29:09.293]                           else {
[17:29:09.293]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:09.293]                               info, version)
[17:29:09.293]                           }
[17:29:09.293]                           base::stop(msg)
[17:29:09.293]                         }
[17:29:09.293]                       })
[17:29:09.293]                     }
[17:29:09.293]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:09.293]                     base::options(mc.cores = 1L)
[17:29:09.293]                   }
[17:29:09.293]                   ...future.strategy.old <- future::plan("list")
[17:29:09.293]                   options(future.plan = NULL)
[17:29:09.293]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:09.293]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:09.293]                 }
[17:29:09.293]                 ...future.workdir <- getwd()
[17:29:09.293]             }
[17:29:09.293]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:09.293]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:09.293]         }
[17:29:09.293]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:09.293]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:09.293]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:09.293]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:09.293]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:09.293]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:09.293]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:09.293]             base::names(...future.oldOptions))
[17:29:09.293]     }
[17:29:09.293]     if (FALSE) {
[17:29:09.293]     }
[17:29:09.293]     else {
[17:29:09.293]         if (TRUE) {
[17:29:09.293]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:09.293]                 open = "w")
[17:29:09.293]         }
[17:29:09.293]         else {
[17:29:09.293]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:09.293]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:09.293]         }
[17:29:09.293]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:09.293]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:09.293]             base::sink(type = "output", split = FALSE)
[17:29:09.293]             base::close(...future.stdout)
[17:29:09.293]         }, add = TRUE)
[17:29:09.293]     }
[17:29:09.293]     ...future.frame <- base::sys.nframe()
[17:29:09.293]     ...future.conditions <- base::list()
[17:29:09.293]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:09.293]     if (FALSE) {
[17:29:09.293]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:09.293]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:09.293]     }
[17:29:09.293]     ...future.result <- base::tryCatch({
[17:29:09.293]         base::withCallingHandlers({
[17:29:09.293]             ...future.value <- base::withVisible(base::local({
[17:29:09.293]                 ...future.makeSendCondition <- base::local({
[17:29:09.293]                   sendCondition <- NULL
[17:29:09.293]                   function(frame = 1L) {
[17:29:09.293]                     if (is.function(sendCondition)) 
[17:29:09.293]                       return(sendCondition)
[17:29:09.293]                     ns <- getNamespace("parallel")
[17:29:09.293]                     if (exists("sendData", mode = "function", 
[17:29:09.293]                       envir = ns)) {
[17:29:09.293]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:09.293]                         envir = ns)
[17:29:09.293]                       envir <- sys.frame(frame)
[17:29:09.293]                       master <- NULL
[17:29:09.293]                       while (!identical(envir, .GlobalEnv) && 
[17:29:09.293]                         !identical(envir, emptyenv())) {
[17:29:09.293]                         if (exists("master", mode = "list", envir = envir, 
[17:29:09.293]                           inherits = FALSE)) {
[17:29:09.293]                           master <- get("master", mode = "list", 
[17:29:09.293]                             envir = envir, inherits = FALSE)
[17:29:09.293]                           if (inherits(master, c("SOCKnode", 
[17:29:09.293]                             "SOCK0node"))) {
[17:29:09.293]                             sendCondition <<- function(cond) {
[17:29:09.293]                               data <- list(type = "VALUE", value = cond, 
[17:29:09.293]                                 success = TRUE)
[17:29:09.293]                               parallel_sendData(master, data)
[17:29:09.293]                             }
[17:29:09.293]                             return(sendCondition)
[17:29:09.293]                           }
[17:29:09.293]                         }
[17:29:09.293]                         frame <- frame + 1L
[17:29:09.293]                         envir <- sys.frame(frame)
[17:29:09.293]                       }
[17:29:09.293]                     }
[17:29:09.293]                     sendCondition <<- function(cond) NULL
[17:29:09.293]                   }
[17:29:09.293]                 })
[17:29:09.293]                 withCallingHandlers({
[17:29:09.293]                   {
[17:29:09.293]                     Sys.sleep(0.5)
[17:29:09.293]                     list(a = 1, b = 42L)
[17:29:09.293]                   }
[17:29:09.293]                 }, immediateCondition = function(cond) {
[17:29:09.293]                   sendCondition <- ...future.makeSendCondition()
[17:29:09.293]                   sendCondition(cond)
[17:29:09.293]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:09.293]                   {
[17:29:09.293]                     inherits <- base::inherits
[17:29:09.293]                     invokeRestart <- base::invokeRestart
[17:29:09.293]                     is.null <- base::is.null
[17:29:09.293]                     muffled <- FALSE
[17:29:09.293]                     if (inherits(cond, "message")) {
[17:29:09.293]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:09.293]                       if (muffled) 
[17:29:09.293]                         invokeRestart("muffleMessage")
[17:29:09.293]                     }
[17:29:09.293]                     else if (inherits(cond, "warning")) {
[17:29:09.293]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:09.293]                       if (muffled) 
[17:29:09.293]                         invokeRestart("muffleWarning")
[17:29:09.293]                     }
[17:29:09.293]                     else if (inherits(cond, "condition")) {
[17:29:09.293]                       if (!is.null(pattern)) {
[17:29:09.293]                         computeRestarts <- base::computeRestarts
[17:29:09.293]                         grepl <- base::grepl
[17:29:09.293]                         restarts <- computeRestarts(cond)
[17:29:09.293]                         for (restart in restarts) {
[17:29:09.293]                           name <- restart$name
[17:29:09.293]                           if (is.null(name)) 
[17:29:09.293]                             next
[17:29:09.293]                           if (!grepl(pattern, name)) 
[17:29:09.293]                             next
[17:29:09.293]                           invokeRestart(restart)
[17:29:09.293]                           muffled <- TRUE
[17:29:09.293]                           break
[17:29:09.293]                         }
[17:29:09.293]                       }
[17:29:09.293]                     }
[17:29:09.293]                     invisible(muffled)
[17:29:09.293]                   }
[17:29:09.293]                   muffleCondition(cond)
[17:29:09.293]                 })
[17:29:09.293]             }))
[17:29:09.293]             future::FutureResult(value = ...future.value$value, 
[17:29:09.293]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:09.293]                   ...future.rng), globalenv = if (FALSE) 
[17:29:09.293]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:09.293]                     ...future.globalenv.names))
[17:29:09.293]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:09.293]         }, condition = base::local({
[17:29:09.293]             c <- base::c
[17:29:09.293]             inherits <- base::inherits
[17:29:09.293]             invokeRestart <- base::invokeRestart
[17:29:09.293]             length <- base::length
[17:29:09.293]             list <- base::list
[17:29:09.293]             seq.int <- base::seq.int
[17:29:09.293]             signalCondition <- base::signalCondition
[17:29:09.293]             sys.calls <- base::sys.calls
[17:29:09.293]             `[[` <- base::`[[`
[17:29:09.293]             `+` <- base::`+`
[17:29:09.293]             `<<-` <- base::`<<-`
[17:29:09.293]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:09.293]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:09.293]                   3L)]
[17:29:09.293]             }
[17:29:09.293]             function(cond) {
[17:29:09.293]                 is_error <- inherits(cond, "error")
[17:29:09.293]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:09.293]                   NULL)
[17:29:09.293]                 if (is_error) {
[17:29:09.293]                   sessionInformation <- function() {
[17:29:09.293]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:09.293]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:09.293]                       search = base::search(), system = base::Sys.info())
[17:29:09.293]                   }
[17:29:09.293]                   ...future.conditions[[length(...future.conditions) + 
[17:29:09.293]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:09.293]                     cond$call), session = sessionInformation(), 
[17:29:09.293]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:09.293]                   signalCondition(cond)
[17:29:09.293]                 }
[17:29:09.293]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:09.293]                 "immediateCondition"))) {
[17:29:09.293]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:09.293]                   ...future.conditions[[length(...future.conditions) + 
[17:29:09.293]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:09.293]                   if (TRUE && !signal) {
[17:29:09.293]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:09.293]                     {
[17:29:09.293]                       inherits <- base::inherits
[17:29:09.293]                       invokeRestart <- base::invokeRestart
[17:29:09.293]                       is.null <- base::is.null
[17:29:09.293]                       muffled <- FALSE
[17:29:09.293]                       if (inherits(cond, "message")) {
[17:29:09.293]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:09.293]                         if (muffled) 
[17:29:09.293]                           invokeRestart("muffleMessage")
[17:29:09.293]                       }
[17:29:09.293]                       else if (inherits(cond, "warning")) {
[17:29:09.293]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:09.293]                         if (muffled) 
[17:29:09.293]                           invokeRestart("muffleWarning")
[17:29:09.293]                       }
[17:29:09.293]                       else if (inherits(cond, "condition")) {
[17:29:09.293]                         if (!is.null(pattern)) {
[17:29:09.293]                           computeRestarts <- base::computeRestarts
[17:29:09.293]                           grepl <- base::grepl
[17:29:09.293]                           restarts <- computeRestarts(cond)
[17:29:09.293]                           for (restart in restarts) {
[17:29:09.293]                             name <- restart$name
[17:29:09.293]                             if (is.null(name)) 
[17:29:09.293]                               next
[17:29:09.293]                             if (!grepl(pattern, name)) 
[17:29:09.293]                               next
[17:29:09.293]                             invokeRestart(restart)
[17:29:09.293]                             muffled <- TRUE
[17:29:09.293]                             break
[17:29:09.293]                           }
[17:29:09.293]                         }
[17:29:09.293]                       }
[17:29:09.293]                       invisible(muffled)
[17:29:09.293]                     }
[17:29:09.293]                     muffleCondition(cond, pattern = "^muffle")
[17:29:09.293]                   }
[17:29:09.293]                 }
[17:29:09.293]                 else {
[17:29:09.293]                   if (TRUE) {
[17:29:09.293]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:09.293]                     {
[17:29:09.293]                       inherits <- base::inherits
[17:29:09.293]                       invokeRestart <- base::invokeRestart
[17:29:09.293]                       is.null <- base::is.null
[17:29:09.293]                       muffled <- FALSE
[17:29:09.293]                       if (inherits(cond, "message")) {
[17:29:09.293]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:09.293]                         if (muffled) 
[17:29:09.293]                           invokeRestart("muffleMessage")
[17:29:09.293]                       }
[17:29:09.293]                       else if (inherits(cond, "warning")) {
[17:29:09.293]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:09.293]                         if (muffled) 
[17:29:09.293]                           invokeRestart("muffleWarning")
[17:29:09.293]                       }
[17:29:09.293]                       else if (inherits(cond, "condition")) {
[17:29:09.293]                         if (!is.null(pattern)) {
[17:29:09.293]                           computeRestarts <- base::computeRestarts
[17:29:09.293]                           grepl <- base::grepl
[17:29:09.293]                           restarts <- computeRestarts(cond)
[17:29:09.293]                           for (restart in restarts) {
[17:29:09.293]                             name <- restart$name
[17:29:09.293]                             if (is.null(name)) 
[17:29:09.293]                               next
[17:29:09.293]                             if (!grepl(pattern, name)) 
[17:29:09.293]                               next
[17:29:09.293]                             invokeRestart(restart)
[17:29:09.293]                             muffled <- TRUE
[17:29:09.293]                             break
[17:29:09.293]                           }
[17:29:09.293]                         }
[17:29:09.293]                       }
[17:29:09.293]                       invisible(muffled)
[17:29:09.293]                     }
[17:29:09.293]                     muffleCondition(cond, pattern = "^muffle")
[17:29:09.293]                   }
[17:29:09.293]                 }
[17:29:09.293]             }
[17:29:09.293]         }))
[17:29:09.293]     }, error = function(ex) {
[17:29:09.293]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:09.293]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:09.293]                 ...future.rng), started = ...future.startTime, 
[17:29:09.293]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:09.293]             version = "1.8"), class = "FutureResult")
[17:29:09.293]     }, finally = {
[17:29:09.293]         if (!identical(...future.workdir, getwd())) 
[17:29:09.293]             setwd(...future.workdir)
[17:29:09.293]         {
[17:29:09.293]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:09.293]                 ...future.oldOptions$nwarnings <- NULL
[17:29:09.293]             }
[17:29:09.293]             base::options(...future.oldOptions)
[17:29:09.293]             if (.Platform$OS.type == "windows") {
[17:29:09.293]                 old_names <- names(...future.oldEnvVars)
[17:29:09.293]                 envs <- base::Sys.getenv()
[17:29:09.293]                 names <- names(envs)
[17:29:09.293]                 common <- intersect(names, old_names)
[17:29:09.293]                 added <- setdiff(names, old_names)
[17:29:09.293]                 removed <- setdiff(old_names, names)
[17:29:09.293]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:09.293]                   envs[common]]
[17:29:09.293]                 NAMES <- toupper(changed)
[17:29:09.293]                 args <- list()
[17:29:09.293]                 for (kk in seq_along(NAMES)) {
[17:29:09.293]                   name <- changed[[kk]]
[17:29:09.293]                   NAME <- NAMES[[kk]]
[17:29:09.293]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:09.293]                     next
[17:29:09.293]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:09.293]                 }
[17:29:09.293]                 NAMES <- toupper(added)
[17:29:09.293]                 for (kk in seq_along(NAMES)) {
[17:29:09.293]                   name <- added[[kk]]
[17:29:09.293]                   NAME <- NAMES[[kk]]
[17:29:09.293]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:09.293]                     next
[17:29:09.293]                   args[[name]] <- ""
[17:29:09.293]                 }
[17:29:09.293]                 NAMES <- toupper(removed)
[17:29:09.293]                 for (kk in seq_along(NAMES)) {
[17:29:09.293]                   name <- removed[[kk]]
[17:29:09.293]                   NAME <- NAMES[[kk]]
[17:29:09.293]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:09.293]                     next
[17:29:09.293]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:09.293]                 }
[17:29:09.293]                 if (length(args) > 0) 
[17:29:09.293]                   base::do.call(base::Sys.setenv, args = args)
[17:29:09.293]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:09.293]             }
[17:29:09.293]             else {
[17:29:09.293]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:09.293]             }
[17:29:09.293]             {
[17:29:09.293]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:09.293]                   0L) {
[17:29:09.293]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:09.293]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:09.293]                   base::options(opts)
[17:29:09.293]                 }
[17:29:09.293]                 {
[17:29:09.293]                   {
[17:29:09.293]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:09.293]                     NULL
[17:29:09.293]                   }
[17:29:09.293]                   options(future.plan = NULL)
[17:29:09.293]                   if (is.na(NA_character_)) 
[17:29:09.293]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:09.293]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:09.293]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:09.293]                     .init = FALSE)
[17:29:09.293]                 }
[17:29:09.293]             }
[17:29:09.293]         }
[17:29:09.293]     })
[17:29:09.293]     if (TRUE) {
[17:29:09.293]         base::sink(type = "output", split = FALSE)
[17:29:09.293]         if (TRUE) {
[17:29:09.293]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:09.293]         }
[17:29:09.293]         else {
[17:29:09.293]             ...future.result["stdout"] <- base::list(NULL)
[17:29:09.293]         }
[17:29:09.293]         base::close(...future.stdout)
[17:29:09.293]         ...future.stdout <- NULL
[17:29:09.293]     }
[17:29:09.293]     ...future.result$conditions <- ...future.conditions
[17:29:09.293]     ...future.result$finished <- base::Sys.time()
[17:29:09.293]     ...future.result
[17:29:09.293] }
[17:29:09.304] MultisessionFuture started
[17:29:09.304] - Launch lazy future ... done
[17:29:09.305] run() for 'MultisessionFuture' ... done
[17:29:09.841] receiveMessageFromWorker() for ClusterFuture ...
[17:29:09.841] - Validating connection of MultisessionFuture
[17:29:09.842] - received message: FutureResult
[17:29:09.842] - Received FutureResult
[17:29:09.843] - Erased future from FutureRegistry
[17:29:09.843] result() for ClusterFuture ...
[17:29:09.843] - result already collected: FutureResult
[17:29:09.844] result() for ClusterFuture ... done
[17:29:09.844] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:09.844] A MultisessionFuture was resolved (result was not collected)
- w/ exception ...
[17:29:09.845] getGlobalsAndPackages() ...
[17:29:09.845] Searching for globals...
[17:29:09.847] - globals found: [2] 'list', 'stop'
[17:29:09.847] Searching for globals ... DONE
[17:29:09.847] Resolving globals: FALSE
[17:29:09.848] 
[17:29:09.848] 
[17:29:09.849] getGlobalsAndPackages() ... DONE
[17:29:09.849] run() for 'Future' ...
[17:29:09.850] - state: 'created'
[17:29:09.850] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:09.871] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:09.871] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:09.871]   - Field: 'node'
[17:29:09.872]   - Field: 'label'
[17:29:09.872]   - Field: 'local'
[17:29:09.873]   - Field: 'owner'
[17:29:09.873]   - Field: 'envir'
[17:29:09.873]   - Field: 'workers'
[17:29:09.874]   - Field: 'packages'
[17:29:09.874]   - Field: 'gc'
[17:29:09.874]   - Field: 'conditions'
[17:29:09.875]   - Field: 'persistent'
[17:29:09.875]   - Field: 'expr'
[17:29:09.875]   - Field: 'uuid'
[17:29:09.876]   - Field: 'seed'
[17:29:09.876]   - Field: 'version'
[17:29:09.876]   - Field: 'result'
[17:29:09.877]   - Field: 'asynchronous'
[17:29:09.877]   - Field: 'calls'
[17:29:09.877]   - Field: 'globals'
[17:29:09.878]   - Field: 'stdout'
[17:29:09.878]   - Field: 'earlySignal'
[17:29:09.879]   - Field: 'lazy'
[17:29:09.879]   - Field: 'state'
[17:29:09.879] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:09.880] - Launch lazy future ...
[17:29:09.880] Packages needed by the future expression (n = 0): <none>
[17:29:09.881] Packages needed by future strategies (n = 0): <none>
[17:29:09.882] {
[17:29:09.882]     {
[17:29:09.882]         {
[17:29:09.882]             ...future.startTime <- base::Sys.time()
[17:29:09.882]             {
[17:29:09.882]                 {
[17:29:09.882]                   {
[17:29:09.882]                     {
[17:29:09.882]                       base::local({
[17:29:09.882]                         has_future <- base::requireNamespace("future", 
[17:29:09.882]                           quietly = TRUE)
[17:29:09.882]                         if (has_future) {
[17:29:09.882]                           ns <- base::getNamespace("future")
[17:29:09.882]                           version <- ns[[".package"]][["version"]]
[17:29:09.882]                           if (is.null(version)) 
[17:29:09.882]                             version <- utils::packageVersion("future")
[17:29:09.882]                         }
[17:29:09.882]                         else {
[17:29:09.882]                           version <- NULL
[17:29:09.882]                         }
[17:29:09.882]                         if (!has_future || version < "1.8.0") {
[17:29:09.882]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:09.882]                             "", base::R.version$version.string), 
[17:29:09.882]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:09.882]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:09.882]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:09.882]                               "release", "version")], collapse = " "), 
[17:29:09.882]                             hostname = base::Sys.info()[["nodename"]])
[17:29:09.882]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:09.882]                             info)
[17:29:09.882]                           info <- base::paste(info, collapse = "; ")
[17:29:09.882]                           if (!has_future) {
[17:29:09.882]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:09.882]                               info)
[17:29:09.882]                           }
[17:29:09.882]                           else {
[17:29:09.882]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:09.882]                               info, version)
[17:29:09.882]                           }
[17:29:09.882]                           base::stop(msg)
[17:29:09.882]                         }
[17:29:09.882]                       })
[17:29:09.882]                     }
[17:29:09.882]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:09.882]                     base::options(mc.cores = 1L)
[17:29:09.882]                   }
[17:29:09.882]                   ...future.strategy.old <- future::plan("list")
[17:29:09.882]                   options(future.plan = NULL)
[17:29:09.882]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:09.882]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:09.882]                 }
[17:29:09.882]                 ...future.workdir <- getwd()
[17:29:09.882]             }
[17:29:09.882]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:09.882]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:09.882]         }
[17:29:09.882]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:09.882]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:09.882]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:09.882]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:09.882]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:09.882]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:09.882]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:09.882]             base::names(...future.oldOptions))
[17:29:09.882]     }
[17:29:09.882]     if (FALSE) {
[17:29:09.882]     }
[17:29:09.882]     else {
[17:29:09.882]         if (TRUE) {
[17:29:09.882]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:09.882]                 open = "w")
[17:29:09.882]         }
[17:29:09.882]         else {
[17:29:09.882]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:09.882]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:09.882]         }
[17:29:09.882]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:09.882]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:09.882]             base::sink(type = "output", split = FALSE)
[17:29:09.882]             base::close(...future.stdout)
[17:29:09.882]         }, add = TRUE)
[17:29:09.882]     }
[17:29:09.882]     ...future.frame <- base::sys.nframe()
[17:29:09.882]     ...future.conditions <- base::list()
[17:29:09.882]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:09.882]     if (FALSE) {
[17:29:09.882]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:09.882]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:09.882]     }
[17:29:09.882]     ...future.result <- base::tryCatch({
[17:29:09.882]         base::withCallingHandlers({
[17:29:09.882]             ...future.value <- base::withVisible(base::local({
[17:29:09.882]                 ...future.makeSendCondition <- base::local({
[17:29:09.882]                   sendCondition <- NULL
[17:29:09.882]                   function(frame = 1L) {
[17:29:09.882]                     if (is.function(sendCondition)) 
[17:29:09.882]                       return(sendCondition)
[17:29:09.882]                     ns <- getNamespace("parallel")
[17:29:09.882]                     if (exists("sendData", mode = "function", 
[17:29:09.882]                       envir = ns)) {
[17:29:09.882]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:09.882]                         envir = ns)
[17:29:09.882]                       envir <- sys.frame(frame)
[17:29:09.882]                       master <- NULL
[17:29:09.882]                       while (!identical(envir, .GlobalEnv) && 
[17:29:09.882]                         !identical(envir, emptyenv())) {
[17:29:09.882]                         if (exists("master", mode = "list", envir = envir, 
[17:29:09.882]                           inherits = FALSE)) {
[17:29:09.882]                           master <- get("master", mode = "list", 
[17:29:09.882]                             envir = envir, inherits = FALSE)
[17:29:09.882]                           if (inherits(master, c("SOCKnode", 
[17:29:09.882]                             "SOCK0node"))) {
[17:29:09.882]                             sendCondition <<- function(cond) {
[17:29:09.882]                               data <- list(type = "VALUE", value = cond, 
[17:29:09.882]                                 success = TRUE)
[17:29:09.882]                               parallel_sendData(master, data)
[17:29:09.882]                             }
[17:29:09.882]                             return(sendCondition)
[17:29:09.882]                           }
[17:29:09.882]                         }
[17:29:09.882]                         frame <- frame + 1L
[17:29:09.882]                         envir <- sys.frame(frame)
[17:29:09.882]                       }
[17:29:09.882]                     }
[17:29:09.882]                     sendCondition <<- function(cond) NULL
[17:29:09.882]                   }
[17:29:09.882]                 })
[17:29:09.882]                 withCallingHandlers({
[17:29:09.882]                   list(a = 1, b = 42L, c = stop("Nah!"))
[17:29:09.882]                 }, immediateCondition = function(cond) {
[17:29:09.882]                   sendCondition <- ...future.makeSendCondition()
[17:29:09.882]                   sendCondition(cond)
[17:29:09.882]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:09.882]                   {
[17:29:09.882]                     inherits <- base::inherits
[17:29:09.882]                     invokeRestart <- base::invokeRestart
[17:29:09.882]                     is.null <- base::is.null
[17:29:09.882]                     muffled <- FALSE
[17:29:09.882]                     if (inherits(cond, "message")) {
[17:29:09.882]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:09.882]                       if (muffled) 
[17:29:09.882]                         invokeRestart("muffleMessage")
[17:29:09.882]                     }
[17:29:09.882]                     else if (inherits(cond, "warning")) {
[17:29:09.882]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:09.882]                       if (muffled) 
[17:29:09.882]                         invokeRestart("muffleWarning")
[17:29:09.882]                     }
[17:29:09.882]                     else if (inherits(cond, "condition")) {
[17:29:09.882]                       if (!is.null(pattern)) {
[17:29:09.882]                         computeRestarts <- base::computeRestarts
[17:29:09.882]                         grepl <- base::grepl
[17:29:09.882]                         restarts <- computeRestarts(cond)
[17:29:09.882]                         for (restart in restarts) {
[17:29:09.882]                           name <- restart$name
[17:29:09.882]                           if (is.null(name)) 
[17:29:09.882]                             next
[17:29:09.882]                           if (!grepl(pattern, name)) 
[17:29:09.882]                             next
[17:29:09.882]                           invokeRestart(restart)
[17:29:09.882]                           muffled <- TRUE
[17:29:09.882]                           break
[17:29:09.882]                         }
[17:29:09.882]                       }
[17:29:09.882]                     }
[17:29:09.882]                     invisible(muffled)
[17:29:09.882]                   }
[17:29:09.882]                   muffleCondition(cond)
[17:29:09.882]                 })
[17:29:09.882]             }))
[17:29:09.882]             future::FutureResult(value = ...future.value$value, 
[17:29:09.882]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:09.882]                   ...future.rng), globalenv = if (FALSE) 
[17:29:09.882]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:09.882]                     ...future.globalenv.names))
[17:29:09.882]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:09.882]         }, condition = base::local({
[17:29:09.882]             c <- base::c
[17:29:09.882]             inherits <- base::inherits
[17:29:09.882]             invokeRestart <- base::invokeRestart
[17:29:09.882]             length <- base::length
[17:29:09.882]             list <- base::list
[17:29:09.882]             seq.int <- base::seq.int
[17:29:09.882]             signalCondition <- base::signalCondition
[17:29:09.882]             sys.calls <- base::sys.calls
[17:29:09.882]             `[[` <- base::`[[`
[17:29:09.882]             `+` <- base::`+`
[17:29:09.882]             `<<-` <- base::`<<-`
[17:29:09.882]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:09.882]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:09.882]                   3L)]
[17:29:09.882]             }
[17:29:09.882]             function(cond) {
[17:29:09.882]                 is_error <- inherits(cond, "error")
[17:29:09.882]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:09.882]                   NULL)
[17:29:09.882]                 if (is_error) {
[17:29:09.882]                   sessionInformation <- function() {
[17:29:09.882]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:09.882]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:09.882]                       search = base::search(), system = base::Sys.info())
[17:29:09.882]                   }
[17:29:09.882]                   ...future.conditions[[length(...future.conditions) + 
[17:29:09.882]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:09.882]                     cond$call), session = sessionInformation(), 
[17:29:09.882]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:09.882]                   signalCondition(cond)
[17:29:09.882]                 }
[17:29:09.882]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:09.882]                 "immediateCondition"))) {
[17:29:09.882]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:09.882]                   ...future.conditions[[length(...future.conditions) + 
[17:29:09.882]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:09.882]                   if (TRUE && !signal) {
[17:29:09.882]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:09.882]                     {
[17:29:09.882]                       inherits <- base::inherits
[17:29:09.882]                       invokeRestart <- base::invokeRestart
[17:29:09.882]                       is.null <- base::is.null
[17:29:09.882]                       muffled <- FALSE
[17:29:09.882]                       if (inherits(cond, "message")) {
[17:29:09.882]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:09.882]                         if (muffled) 
[17:29:09.882]                           invokeRestart("muffleMessage")
[17:29:09.882]                       }
[17:29:09.882]                       else if (inherits(cond, "warning")) {
[17:29:09.882]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:09.882]                         if (muffled) 
[17:29:09.882]                           invokeRestart("muffleWarning")
[17:29:09.882]                       }
[17:29:09.882]                       else if (inherits(cond, "condition")) {
[17:29:09.882]                         if (!is.null(pattern)) {
[17:29:09.882]                           computeRestarts <- base::computeRestarts
[17:29:09.882]                           grepl <- base::grepl
[17:29:09.882]                           restarts <- computeRestarts(cond)
[17:29:09.882]                           for (restart in restarts) {
[17:29:09.882]                             name <- restart$name
[17:29:09.882]                             if (is.null(name)) 
[17:29:09.882]                               next
[17:29:09.882]                             if (!grepl(pattern, name)) 
[17:29:09.882]                               next
[17:29:09.882]                             invokeRestart(restart)
[17:29:09.882]                             muffled <- TRUE
[17:29:09.882]                             break
[17:29:09.882]                           }
[17:29:09.882]                         }
[17:29:09.882]                       }
[17:29:09.882]                       invisible(muffled)
[17:29:09.882]                     }
[17:29:09.882]                     muffleCondition(cond, pattern = "^muffle")
[17:29:09.882]                   }
[17:29:09.882]                 }
[17:29:09.882]                 else {
[17:29:09.882]                   if (TRUE) {
[17:29:09.882]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:09.882]                     {
[17:29:09.882]                       inherits <- base::inherits
[17:29:09.882]                       invokeRestart <- base::invokeRestart
[17:29:09.882]                       is.null <- base::is.null
[17:29:09.882]                       muffled <- FALSE
[17:29:09.882]                       if (inherits(cond, "message")) {
[17:29:09.882]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:09.882]                         if (muffled) 
[17:29:09.882]                           invokeRestart("muffleMessage")
[17:29:09.882]                       }
[17:29:09.882]                       else if (inherits(cond, "warning")) {
[17:29:09.882]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:09.882]                         if (muffled) 
[17:29:09.882]                           invokeRestart("muffleWarning")
[17:29:09.882]                       }
[17:29:09.882]                       else if (inherits(cond, "condition")) {
[17:29:09.882]                         if (!is.null(pattern)) {
[17:29:09.882]                           computeRestarts <- base::computeRestarts
[17:29:09.882]                           grepl <- base::grepl
[17:29:09.882]                           restarts <- computeRestarts(cond)
[17:29:09.882]                           for (restart in restarts) {
[17:29:09.882]                             name <- restart$name
[17:29:09.882]                             if (is.null(name)) 
[17:29:09.882]                               next
[17:29:09.882]                             if (!grepl(pattern, name)) 
[17:29:09.882]                               next
[17:29:09.882]                             invokeRestart(restart)
[17:29:09.882]                             muffled <- TRUE
[17:29:09.882]                             break
[17:29:09.882]                           }
[17:29:09.882]                         }
[17:29:09.882]                       }
[17:29:09.882]                       invisible(muffled)
[17:29:09.882]                     }
[17:29:09.882]                     muffleCondition(cond, pattern = "^muffle")
[17:29:09.882]                   }
[17:29:09.882]                 }
[17:29:09.882]             }
[17:29:09.882]         }))
[17:29:09.882]     }, error = function(ex) {
[17:29:09.882]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:09.882]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:09.882]                 ...future.rng), started = ...future.startTime, 
[17:29:09.882]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:09.882]             version = "1.8"), class = "FutureResult")
[17:29:09.882]     }, finally = {
[17:29:09.882]         if (!identical(...future.workdir, getwd())) 
[17:29:09.882]             setwd(...future.workdir)
[17:29:09.882]         {
[17:29:09.882]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:09.882]                 ...future.oldOptions$nwarnings <- NULL
[17:29:09.882]             }
[17:29:09.882]             base::options(...future.oldOptions)
[17:29:09.882]             if (.Platform$OS.type == "windows") {
[17:29:09.882]                 old_names <- names(...future.oldEnvVars)
[17:29:09.882]                 envs <- base::Sys.getenv()
[17:29:09.882]                 names <- names(envs)
[17:29:09.882]                 common <- intersect(names, old_names)
[17:29:09.882]                 added <- setdiff(names, old_names)
[17:29:09.882]                 removed <- setdiff(old_names, names)
[17:29:09.882]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:09.882]                   envs[common]]
[17:29:09.882]                 NAMES <- toupper(changed)
[17:29:09.882]                 args <- list()
[17:29:09.882]                 for (kk in seq_along(NAMES)) {
[17:29:09.882]                   name <- changed[[kk]]
[17:29:09.882]                   NAME <- NAMES[[kk]]
[17:29:09.882]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:09.882]                     next
[17:29:09.882]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:09.882]                 }
[17:29:09.882]                 NAMES <- toupper(added)
[17:29:09.882]                 for (kk in seq_along(NAMES)) {
[17:29:09.882]                   name <- added[[kk]]
[17:29:09.882]                   NAME <- NAMES[[kk]]
[17:29:09.882]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:09.882]                     next
[17:29:09.882]                   args[[name]] <- ""
[17:29:09.882]                 }
[17:29:09.882]                 NAMES <- toupper(removed)
[17:29:09.882]                 for (kk in seq_along(NAMES)) {
[17:29:09.882]                   name <- removed[[kk]]
[17:29:09.882]                   NAME <- NAMES[[kk]]
[17:29:09.882]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:09.882]                     next
[17:29:09.882]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:09.882]                 }
[17:29:09.882]                 if (length(args) > 0) 
[17:29:09.882]                   base::do.call(base::Sys.setenv, args = args)
[17:29:09.882]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:09.882]             }
[17:29:09.882]             else {
[17:29:09.882]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:09.882]             }
[17:29:09.882]             {
[17:29:09.882]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:09.882]                   0L) {
[17:29:09.882]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:09.882]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:09.882]                   base::options(opts)
[17:29:09.882]                 }
[17:29:09.882]                 {
[17:29:09.882]                   {
[17:29:09.882]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:09.882]                     NULL
[17:29:09.882]                   }
[17:29:09.882]                   options(future.plan = NULL)
[17:29:09.882]                   if (is.na(NA_character_)) 
[17:29:09.882]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:09.882]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:09.882]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:09.882]                     .init = FALSE)
[17:29:09.882]                 }
[17:29:09.882]             }
[17:29:09.882]         }
[17:29:09.882]     })
[17:29:09.882]     if (TRUE) {
[17:29:09.882]         base::sink(type = "output", split = FALSE)
[17:29:09.882]         if (TRUE) {
[17:29:09.882]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:09.882]         }
[17:29:09.882]         else {
[17:29:09.882]             ...future.result["stdout"] <- base::list(NULL)
[17:29:09.882]         }
[17:29:09.882]         base::close(...future.stdout)
[17:29:09.882]         ...future.stdout <- NULL
[17:29:09.882]     }
[17:29:09.882]     ...future.result$conditions <- ...future.conditions
[17:29:09.882]     ...future.result$finished <- base::Sys.time()
[17:29:09.882]     ...future.result
[17:29:09.882] }
[17:29:09.892] MultisessionFuture started
[17:29:09.892] - Launch lazy future ... done
[17:29:09.892] run() for 'MultisessionFuture' ... done
[17:29:09.917] receiveMessageFromWorker() for ClusterFuture ...
[17:29:09.917] - Validating connection of MultisessionFuture
[17:29:09.919] - received message: FutureResult
[17:29:09.919] - Received FutureResult
[17:29:09.920] - Erased future from FutureRegistry
[17:29:09.920] result() for ClusterFuture ...
[17:29:09.920] - result already collected: FutureResult
[17:29:09.921] result() for ClusterFuture ... done
[17:29:09.921] signalConditions() ...
[17:29:09.921]  - include = 'immediateCondition'
[17:29:09.922]  - exclude = 
[17:29:09.922]  - resignal = FALSE
[17:29:09.923]  - Number of conditions: 1
[17:29:09.923] signalConditions() ... done
[17:29:09.923] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:09.924] A MultisessionFuture was resolved (result was not collected)
[17:29:09.924] getGlobalsAndPackages() ...
[17:29:09.925] Searching for globals...
[17:29:09.927] - globals found: [2] 'list', 'stop'
[17:29:09.927] Searching for globals ... DONE
[17:29:09.927] Resolving globals: FALSE
[17:29:09.928] 
[17:29:09.929] 
[17:29:09.929] getGlobalsAndPackages() ... DONE
[17:29:09.930] run() for 'Future' ...
[17:29:09.930] - state: 'created'
[17:29:09.931] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:09.956] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:09.956] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:09.956]   - Field: 'node'
[17:29:09.957]   - Field: 'label'
[17:29:09.957]   - Field: 'local'
[17:29:09.957]   - Field: 'owner'
[17:29:09.958]   - Field: 'envir'
[17:29:09.958]   - Field: 'workers'
[17:29:09.958]   - Field: 'packages'
[17:29:09.959]   - Field: 'gc'
[17:29:09.959]   - Field: 'conditions'
[17:29:09.959]   - Field: 'persistent'
[17:29:09.960]   - Field: 'expr'
[17:29:09.960]   - Field: 'uuid'
[17:29:09.961]   - Field: 'seed'
[17:29:09.961]   - Field: 'version'
[17:29:09.961]   - Field: 'result'
[17:29:09.962]   - Field: 'asynchronous'
[17:29:09.962]   - Field: 'calls'
[17:29:09.962]   - Field: 'globals'
[17:29:09.963]   - Field: 'stdout'
[17:29:09.963]   - Field: 'earlySignal'
[17:29:09.963]   - Field: 'lazy'
[17:29:09.964]   - Field: 'state'
[17:29:09.964] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:09.964] - Launch lazy future ...
[17:29:09.965] Packages needed by the future expression (n = 0): <none>
[17:29:09.965] Packages needed by future strategies (n = 0): <none>
[17:29:09.966] {
[17:29:09.966]     {
[17:29:09.966]         {
[17:29:09.966]             ...future.startTime <- base::Sys.time()
[17:29:09.966]             {
[17:29:09.966]                 {
[17:29:09.966]                   {
[17:29:09.966]                     {
[17:29:09.966]                       base::local({
[17:29:09.966]                         has_future <- base::requireNamespace("future", 
[17:29:09.966]                           quietly = TRUE)
[17:29:09.966]                         if (has_future) {
[17:29:09.966]                           ns <- base::getNamespace("future")
[17:29:09.966]                           version <- ns[[".package"]][["version"]]
[17:29:09.966]                           if (is.null(version)) 
[17:29:09.966]                             version <- utils::packageVersion("future")
[17:29:09.966]                         }
[17:29:09.966]                         else {
[17:29:09.966]                           version <- NULL
[17:29:09.966]                         }
[17:29:09.966]                         if (!has_future || version < "1.8.0") {
[17:29:09.966]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:09.966]                             "", base::R.version$version.string), 
[17:29:09.966]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:09.966]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:09.966]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:09.966]                               "release", "version")], collapse = " "), 
[17:29:09.966]                             hostname = base::Sys.info()[["nodename"]])
[17:29:09.966]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:09.966]                             info)
[17:29:09.966]                           info <- base::paste(info, collapse = "; ")
[17:29:09.966]                           if (!has_future) {
[17:29:09.966]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:09.966]                               info)
[17:29:09.966]                           }
[17:29:09.966]                           else {
[17:29:09.966]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:09.966]                               info, version)
[17:29:09.966]                           }
[17:29:09.966]                           base::stop(msg)
[17:29:09.966]                         }
[17:29:09.966]                       })
[17:29:09.966]                     }
[17:29:09.966]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:09.966]                     base::options(mc.cores = 1L)
[17:29:09.966]                   }
[17:29:09.966]                   ...future.strategy.old <- future::plan("list")
[17:29:09.966]                   options(future.plan = NULL)
[17:29:09.966]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:09.966]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:09.966]                 }
[17:29:09.966]                 ...future.workdir <- getwd()
[17:29:09.966]             }
[17:29:09.966]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:09.966]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:09.966]         }
[17:29:09.966]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:09.966]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:09.966]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:09.966]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:09.966]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:09.966]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:09.966]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:09.966]             base::names(...future.oldOptions))
[17:29:09.966]     }
[17:29:09.966]     if (FALSE) {
[17:29:09.966]     }
[17:29:09.966]     else {
[17:29:09.966]         if (TRUE) {
[17:29:09.966]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:09.966]                 open = "w")
[17:29:09.966]         }
[17:29:09.966]         else {
[17:29:09.966]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:09.966]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:09.966]         }
[17:29:09.966]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:09.966]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:09.966]             base::sink(type = "output", split = FALSE)
[17:29:09.966]             base::close(...future.stdout)
[17:29:09.966]         }, add = TRUE)
[17:29:09.966]     }
[17:29:09.966]     ...future.frame <- base::sys.nframe()
[17:29:09.966]     ...future.conditions <- base::list()
[17:29:09.966]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:09.966]     if (FALSE) {
[17:29:09.966]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:09.966]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:09.966]     }
[17:29:09.966]     ...future.result <- base::tryCatch({
[17:29:09.966]         base::withCallingHandlers({
[17:29:09.966]             ...future.value <- base::withVisible(base::local({
[17:29:09.966]                 ...future.makeSendCondition <- base::local({
[17:29:09.966]                   sendCondition <- NULL
[17:29:09.966]                   function(frame = 1L) {
[17:29:09.966]                     if (is.function(sendCondition)) 
[17:29:09.966]                       return(sendCondition)
[17:29:09.966]                     ns <- getNamespace("parallel")
[17:29:09.966]                     if (exists("sendData", mode = "function", 
[17:29:09.966]                       envir = ns)) {
[17:29:09.966]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:09.966]                         envir = ns)
[17:29:09.966]                       envir <- sys.frame(frame)
[17:29:09.966]                       master <- NULL
[17:29:09.966]                       while (!identical(envir, .GlobalEnv) && 
[17:29:09.966]                         !identical(envir, emptyenv())) {
[17:29:09.966]                         if (exists("master", mode = "list", envir = envir, 
[17:29:09.966]                           inherits = FALSE)) {
[17:29:09.966]                           master <- get("master", mode = "list", 
[17:29:09.966]                             envir = envir, inherits = FALSE)
[17:29:09.966]                           if (inherits(master, c("SOCKnode", 
[17:29:09.966]                             "SOCK0node"))) {
[17:29:09.966]                             sendCondition <<- function(cond) {
[17:29:09.966]                               data <- list(type = "VALUE", value = cond, 
[17:29:09.966]                                 success = TRUE)
[17:29:09.966]                               parallel_sendData(master, data)
[17:29:09.966]                             }
[17:29:09.966]                             return(sendCondition)
[17:29:09.966]                           }
[17:29:09.966]                         }
[17:29:09.966]                         frame <- frame + 1L
[17:29:09.966]                         envir <- sys.frame(frame)
[17:29:09.966]                       }
[17:29:09.966]                     }
[17:29:09.966]                     sendCondition <<- function(cond) NULL
[17:29:09.966]                   }
[17:29:09.966]                 })
[17:29:09.966]                 withCallingHandlers({
[17:29:09.966]                   list(a = 1, b = 42L, c = stop("Nah!"))
[17:29:09.966]                 }, immediateCondition = function(cond) {
[17:29:09.966]                   sendCondition <- ...future.makeSendCondition()
[17:29:09.966]                   sendCondition(cond)
[17:29:09.966]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:09.966]                   {
[17:29:09.966]                     inherits <- base::inherits
[17:29:09.966]                     invokeRestart <- base::invokeRestart
[17:29:09.966]                     is.null <- base::is.null
[17:29:09.966]                     muffled <- FALSE
[17:29:09.966]                     if (inherits(cond, "message")) {
[17:29:09.966]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:09.966]                       if (muffled) 
[17:29:09.966]                         invokeRestart("muffleMessage")
[17:29:09.966]                     }
[17:29:09.966]                     else if (inherits(cond, "warning")) {
[17:29:09.966]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:09.966]                       if (muffled) 
[17:29:09.966]                         invokeRestart("muffleWarning")
[17:29:09.966]                     }
[17:29:09.966]                     else if (inherits(cond, "condition")) {
[17:29:09.966]                       if (!is.null(pattern)) {
[17:29:09.966]                         computeRestarts <- base::computeRestarts
[17:29:09.966]                         grepl <- base::grepl
[17:29:09.966]                         restarts <- computeRestarts(cond)
[17:29:09.966]                         for (restart in restarts) {
[17:29:09.966]                           name <- restart$name
[17:29:09.966]                           if (is.null(name)) 
[17:29:09.966]                             next
[17:29:09.966]                           if (!grepl(pattern, name)) 
[17:29:09.966]                             next
[17:29:09.966]                           invokeRestart(restart)
[17:29:09.966]                           muffled <- TRUE
[17:29:09.966]                           break
[17:29:09.966]                         }
[17:29:09.966]                       }
[17:29:09.966]                     }
[17:29:09.966]                     invisible(muffled)
[17:29:09.966]                   }
[17:29:09.966]                   muffleCondition(cond)
[17:29:09.966]                 })
[17:29:09.966]             }))
[17:29:09.966]             future::FutureResult(value = ...future.value$value, 
[17:29:09.966]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:09.966]                   ...future.rng), globalenv = if (FALSE) 
[17:29:09.966]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:09.966]                     ...future.globalenv.names))
[17:29:09.966]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:09.966]         }, condition = base::local({
[17:29:09.966]             c <- base::c
[17:29:09.966]             inherits <- base::inherits
[17:29:09.966]             invokeRestart <- base::invokeRestart
[17:29:09.966]             length <- base::length
[17:29:09.966]             list <- base::list
[17:29:09.966]             seq.int <- base::seq.int
[17:29:09.966]             signalCondition <- base::signalCondition
[17:29:09.966]             sys.calls <- base::sys.calls
[17:29:09.966]             `[[` <- base::`[[`
[17:29:09.966]             `+` <- base::`+`
[17:29:09.966]             `<<-` <- base::`<<-`
[17:29:09.966]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:09.966]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:09.966]                   3L)]
[17:29:09.966]             }
[17:29:09.966]             function(cond) {
[17:29:09.966]                 is_error <- inherits(cond, "error")
[17:29:09.966]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:09.966]                   NULL)
[17:29:09.966]                 if (is_error) {
[17:29:09.966]                   sessionInformation <- function() {
[17:29:09.966]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:09.966]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:09.966]                       search = base::search(), system = base::Sys.info())
[17:29:09.966]                   }
[17:29:09.966]                   ...future.conditions[[length(...future.conditions) + 
[17:29:09.966]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:09.966]                     cond$call), session = sessionInformation(), 
[17:29:09.966]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:09.966]                   signalCondition(cond)
[17:29:09.966]                 }
[17:29:09.966]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:09.966]                 "immediateCondition"))) {
[17:29:09.966]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:09.966]                   ...future.conditions[[length(...future.conditions) + 
[17:29:09.966]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:09.966]                   if (TRUE && !signal) {
[17:29:09.966]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:09.966]                     {
[17:29:09.966]                       inherits <- base::inherits
[17:29:09.966]                       invokeRestart <- base::invokeRestart
[17:29:09.966]                       is.null <- base::is.null
[17:29:09.966]                       muffled <- FALSE
[17:29:09.966]                       if (inherits(cond, "message")) {
[17:29:09.966]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:09.966]                         if (muffled) 
[17:29:09.966]                           invokeRestart("muffleMessage")
[17:29:09.966]                       }
[17:29:09.966]                       else if (inherits(cond, "warning")) {
[17:29:09.966]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:09.966]                         if (muffled) 
[17:29:09.966]                           invokeRestart("muffleWarning")
[17:29:09.966]                       }
[17:29:09.966]                       else if (inherits(cond, "condition")) {
[17:29:09.966]                         if (!is.null(pattern)) {
[17:29:09.966]                           computeRestarts <- base::computeRestarts
[17:29:09.966]                           grepl <- base::grepl
[17:29:09.966]                           restarts <- computeRestarts(cond)
[17:29:09.966]                           for (restart in restarts) {
[17:29:09.966]                             name <- restart$name
[17:29:09.966]                             if (is.null(name)) 
[17:29:09.966]                               next
[17:29:09.966]                             if (!grepl(pattern, name)) 
[17:29:09.966]                               next
[17:29:09.966]                             invokeRestart(restart)
[17:29:09.966]                             muffled <- TRUE
[17:29:09.966]                             break
[17:29:09.966]                           }
[17:29:09.966]                         }
[17:29:09.966]                       }
[17:29:09.966]                       invisible(muffled)
[17:29:09.966]                     }
[17:29:09.966]                     muffleCondition(cond, pattern = "^muffle")
[17:29:09.966]                   }
[17:29:09.966]                 }
[17:29:09.966]                 else {
[17:29:09.966]                   if (TRUE) {
[17:29:09.966]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:09.966]                     {
[17:29:09.966]                       inherits <- base::inherits
[17:29:09.966]                       invokeRestart <- base::invokeRestart
[17:29:09.966]                       is.null <- base::is.null
[17:29:09.966]                       muffled <- FALSE
[17:29:09.966]                       if (inherits(cond, "message")) {
[17:29:09.966]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:09.966]                         if (muffled) 
[17:29:09.966]                           invokeRestart("muffleMessage")
[17:29:09.966]                       }
[17:29:09.966]                       else if (inherits(cond, "warning")) {
[17:29:09.966]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:09.966]                         if (muffled) 
[17:29:09.966]                           invokeRestart("muffleWarning")
[17:29:09.966]                       }
[17:29:09.966]                       else if (inherits(cond, "condition")) {
[17:29:09.966]                         if (!is.null(pattern)) {
[17:29:09.966]                           computeRestarts <- base::computeRestarts
[17:29:09.966]                           grepl <- base::grepl
[17:29:09.966]                           restarts <- computeRestarts(cond)
[17:29:09.966]                           for (restart in restarts) {
[17:29:09.966]                             name <- restart$name
[17:29:09.966]                             if (is.null(name)) 
[17:29:09.966]                               next
[17:29:09.966]                             if (!grepl(pattern, name)) 
[17:29:09.966]                               next
[17:29:09.966]                             invokeRestart(restart)
[17:29:09.966]                             muffled <- TRUE
[17:29:09.966]                             break
[17:29:09.966]                           }
[17:29:09.966]                         }
[17:29:09.966]                       }
[17:29:09.966]                       invisible(muffled)
[17:29:09.966]                     }
[17:29:09.966]                     muffleCondition(cond, pattern = "^muffle")
[17:29:09.966]                   }
[17:29:09.966]                 }
[17:29:09.966]             }
[17:29:09.966]         }))
[17:29:09.966]     }, error = function(ex) {
[17:29:09.966]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:09.966]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:09.966]                 ...future.rng), started = ...future.startTime, 
[17:29:09.966]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:09.966]             version = "1.8"), class = "FutureResult")
[17:29:09.966]     }, finally = {
[17:29:09.966]         if (!identical(...future.workdir, getwd())) 
[17:29:09.966]             setwd(...future.workdir)
[17:29:09.966]         {
[17:29:09.966]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:09.966]                 ...future.oldOptions$nwarnings <- NULL
[17:29:09.966]             }
[17:29:09.966]             base::options(...future.oldOptions)
[17:29:09.966]             if (.Platform$OS.type == "windows") {
[17:29:09.966]                 old_names <- names(...future.oldEnvVars)
[17:29:09.966]                 envs <- base::Sys.getenv()
[17:29:09.966]                 names <- names(envs)
[17:29:09.966]                 common <- intersect(names, old_names)
[17:29:09.966]                 added <- setdiff(names, old_names)
[17:29:09.966]                 removed <- setdiff(old_names, names)
[17:29:09.966]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:09.966]                   envs[common]]
[17:29:09.966]                 NAMES <- toupper(changed)
[17:29:09.966]                 args <- list()
[17:29:09.966]                 for (kk in seq_along(NAMES)) {
[17:29:09.966]                   name <- changed[[kk]]
[17:29:09.966]                   NAME <- NAMES[[kk]]
[17:29:09.966]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:09.966]                     next
[17:29:09.966]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:09.966]                 }
[17:29:09.966]                 NAMES <- toupper(added)
[17:29:09.966]                 for (kk in seq_along(NAMES)) {
[17:29:09.966]                   name <- added[[kk]]
[17:29:09.966]                   NAME <- NAMES[[kk]]
[17:29:09.966]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:09.966]                     next
[17:29:09.966]                   args[[name]] <- ""
[17:29:09.966]                 }
[17:29:09.966]                 NAMES <- toupper(removed)
[17:29:09.966]                 for (kk in seq_along(NAMES)) {
[17:29:09.966]                   name <- removed[[kk]]
[17:29:09.966]                   NAME <- NAMES[[kk]]
[17:29:09.966]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:09.966]                     next
[17:29:09.966]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:09.966]                 }
[17:29:09.966]                 if (length(args) > 0) 
[17:29:09.966]                   base::do.call(base::Sys.setenv, args = args)
[17:29:09.966]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:09.966]             }
[17:29:09.966]             else {
[17:29:09.966]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:09.966]             }
[17:29:09.966]             {
[17:29:09.966]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:09.966]                   0L) {
[17:29:09.966]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:09.966]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:09.966]                   base::options(opts)
[17:29:09.966]                 }
[17:29:09.966]                 {
[17:29:09.966]                   {
[17:29:09.966]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:09.966]                     NULL
[17:29:09.966]                   }
[17:29:09.966]                   options(future.plan = NULL)
[17:29:09.966]                   if (is.na(NA_character_)) 
[17:29:09.966]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:09.966]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:09.966]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:09.966]                     .init = FALSE)
[17:29:09.966]                 }
[17:29:09.966]             }
[17:29:09.966]         }
[17:29:09.966]     })
[17:29:09.966]     if (TRUE) {
[17:29:09.966]         base::sink(type = "output", split = FALSE)
[17:29:09.966]         if (TRUE) {
[17:29:09.966]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:09.966]         }
[17:29:09.966]         else {
[17:29:09.966]             ...future.result["stdout"] <- base::list(NULL)
[17:29:09.966]         }
[17:29:09.966]         base::close(...future.stdout)
[17:29:09.966]         ...future.stdout <- NULL
[17:29:09.966]     }
[17:29:09.966]     ...future.result$conditions <- ...future.conditions
[17:29:09.966]     ...future.result$finished <- base::Sys.time()
[17:29:09.966]     ...future.result
[17:29:09.966] }
[17:29:09.978] MultisessionFuture started
[17:29:09.979] - Launch lazy future ... done
[17:29:09.979] run() for 'MultisessionFuture' ... done
[17:29:10.010] receiveMessageFromWorker() for ClusterFuture ...
[17:29:10.010] - Validating connection of MultisessionFuture
[17:29:10.011] - received message: FutureResult
[17:29:10.011] - Received FutureResult
[17:29:10.012] - Erased future from FutureRegistry
[17:29:10.012] result() for ClusterFuture ...
[17:29:10.012] - result already collected: FutureResult
[17:29:10.012] result() for ClusterFuture ... done
[17:29:10.013] signalConditions() ...
[17:29:10.013]  - include = 'immediateCondition'
[17:29:10.013]  - exclude = 
[17:29:10.013]  - resignal = FALSE
[17:29:10.013]  - Number of conditions: 1
[17:29:10.014] signalConditions() ... done
[17:29:10.014] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:10.014] A MultisessionFuture was resolved (result was not collected)
- result = FALSE, recursive = TRUE ... DONE
- result = FALSE, recursive = -1 ...
[17:29:10.015] getGlobalsAndPackages() ...
[17:29:10.015] Searching for globals...
[17:29:10.017] - globals found: [3] '{', 'Sys.sleep', 'list'
[17:29:10.018] Searching for globals ... DONE
[17:29:10.018] Resolving globals: FALSE
[17:29:10.019] 
[17:29:10.019] 
[17:29:10.019] getGlobalsAndPackages() ... DONE
[17:29:10.020] run() for 'Future' ...
[17:29:10.020] - state: 'created'
[17:29:10.021] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:10.040] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:10.041] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:10.041]   - Field: 'node'
[17:29:10.041]   - Field: 'label'
[17:29:10.042]   - Field: 'local'
[17:29:10.042]   - Field: 'owner'
[17:29:10.042]   - Field: 'envir'
[17:29:10.043]   - Field: 'workers'
[17:29:10.043]   - Field: 'packages'
[17:29:10.043]   - Field: 'gc'
[17:29:10.044]   - Field: 'conditions'
[17:29:10.044]   - Field: 'persistent'
[17:29:10.044]   - Field: 'expr'
[17:29:10.045]   - Field: 'uuid'
[17:29:10.045]   - Field: 'seed'
[17:29:10.045]   - Field: 'version'
[17:29:10.045]   - Field: 'result'
[17:29:10.046]   - Field: 'asynchronous'
[17:29:10.046]   - Field: 'calls'
[17:29:10.046]   - Field: 'globals'
[17:29:10.047]   - Field: 'stdout'
[17:29:10.047]   - Field: 'earlySignal'
[17:29:10.047]   - Field: 'lazy'
[17:29:10.047]   - Field: 'state'
[17:29:10.048] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:10.048] - Launch lazy future ...
[17:29:10.049] Packages needed by the future expression (n = 0): <none>
[17:29:10.049] Packages needed by future strategies (n = 0): <none>
[17:29:10.050] {
[17:29:10.050]     {
[17:29:10.050]         {
[17:29:10.050]             ...future.startTime <- base::Sys.time()
[17:29:10.050]             {
[17:29:10.050]                 {
[17:29:10.050]                   {
[17:29:10.050]                     {
[17:29:10.050]                       base::local({
[17:29:10.050]                         has_future <- base::requireNamespace("future", 
[17:29:10.050]                           quietly = TRUE)
[17:29:10.050]                         if (has_future) {
[17:29:10.050]                           ns <- base::getNamespace("future")
[17:29:10.050]                           version <- ns[[".package"]][["version"]]
[17:29:10.050]                           if (is.null(version)) 
[17:29:10.050]                             version <- utils::packageVersion("future")
[17:29:10.050]                         }
[17:29:10.050]                         else {
[17:29:10.050]                           version <- NULL
[17:29:10.050]                         }
[17:29:10.050]                         if (!has_future || version < "1.8.0") {
[17:29:10.050]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:10.050]                             "", base::R.version$version.string), 
[17:29:10.050]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:10.050]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:10.050]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:10.050]                               "release", "version")], collapse = " "), 
[17:29:10.050]                             hostname = base::Sys.info()[["nodename"]])
[17:29:10.050]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:10.050]                             info)
[17:29:10.050]                           info <- base::paste(info, collapse = "; ")
[17:29:10.050]                           if (!has_future) {
[17:29:10.050]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:10.050]                               info)
[17:29:10.050]                           }
[17:29:10.050]                           else {
[17:29:10.050]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:10.050]                               info, version)
[17:29:10.050]                           }
[17:29:10.050]                           base::stop(msg)
[17:29:10.050]                         }
[17:29:10.050]                       })
[17:29:10.050]                     }
[17:29:10.050]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:10.050]                     base::options(mc.cores = 1L)
[17:29:10.050]                   }
[17:29:10.050]                   ...future.strategy.old <- future::plan("list")
[17:29:10.050]                   options(future.plan = NULL)
[17:29:10.050]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:10.050]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:10.050]                 }
[17:29:10.050]                 ...future.workdir <- getwd()
[17:29:10.050]             }
[17:29:10.050]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:10.050]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:10.050]         }
[17:29:10.050]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:10.050]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:10.050]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:10.050]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:10.050]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:10.050]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:10.050]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:10.050]             base::names(...future.oldOptions))
[17:29:10.050]     }
[17:29:10.050]     if (FALSE) {
[17:29:10.050]     }
[17:29:10.050]     else {
[17:29:10.050]         if (TRUE) {
[17:29:10.050]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:10.050]                 open = "w")
[17:29:10.050]         }
[17:29:10.050]         else {
[17:29:10.050]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:10.050]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:10.050]         }
[17:29:10.050]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:10.050]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:10.050]             base::sink(type = "output", split = FALSE)
[17:29:10.050]             base::close(...future.stdout)
[17:29:10.050]         }, add = TRUE)
[17:29:10.050]     }
[17:29:10.050]     ...future.frame <- base::sys.nframe()
[17:29:10.050]     ...future.conditions <- base::list()
[17:29:10.050]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:10.050]     if (FALSE) {
[17:29:10.050]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:10.050]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:10.050]     }
[17:29:10.050]     ...future.result <- base::tryCatch({
[17:29:10.050]         base::withCallingHandlers({
[17:29:10.050]             ...future.value <- base::withVisible(base::local({
[17:29:10.050]                 ...future.makeSendCondition <- base::local({
[17:29:10.050]                   sendCondition <- NULL
[17:29:10.050]                   function(frame = 1L) {
[17:29:10.050]                     if (is.function(sendCondition)) 
[17:29:10.050]                       return(sendCondition)
[17:29:10.050]                     ns <- getNamespace("parallel")
[17:29:10.050]                     if (exists("sendData", mode = "function", 
[17:29:10.050]                       envir = ns)) {
[17:29:10.050]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:10.050]                         envir = ns)
[17:29:10.050]                       envir <- sys.frame(frame)
[17:29:10.050]                       master <- NULL
[17:29:10.050]                       while (!identical(envir, .GlobalEnv) && 
[17:29:10.050]                         !identical(envir, emptyenv())) {
[17:29:10.050]                         if (exists("master", mode = "list", envir = envir, 
[17:29:10.050]                           inherits = FALSE)) {
[17:29:10.050]                           master <- get("master", mode = "list", 
[17:29:10.050]                             envir = envir, inherits = FALSE)
[17:29:10.050]                           if (inherits(master, c("SOCKnode", 
[17:29:10.050]                             "SOCK0node"))) {
[17:29:10.050]                             sendCondition <<- function(cond) {
[17:29:10.050]                               data <- list(type = "VALUE", value = cond, 
[17:29:10.050]                                 success = TRUE)
[17:29:10.050]                               parallel_sendData(master, data)
[17:29:10.050]                             }
[17:29:10.050]                             return(sendCondition)
[17:29:10.050]                           }
[17:29:10.050]                         }
[17:29:10.050]                         frame <- frame + 1L
[17:29:10.050]                         envir <- sys.frame(frame)
[17:29:10.050]                       }
[17:29:10.050]                     }
[17:29:10.050]                     sendCondition <<- function(cond) NULL
[17:29:10.050]                   }
[17:29:10.050]                 })
[17:29:10.050]                 withCallingHandlers({
[17:29:10.050]                   {
[17:29:10.050]                     Sys.sleep(0.5)
[17:29:10.050]                     list(a = 1, b = 42L)
[17:29:10.050]                   }
[17:29:10.050]                 }, immediateCondition = function(cond) {
[17:29:10.050]                   sendCondition <- ...future.makeSendCondition()
[17:29:10.050]                   sendCondition(cond)
[17:29:10.050]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:10.050]                   {
[17:29:10.050]                     inherits <- base::inherits
[17:29:10.050]                     invokeRestart <- base::invokeRestart
[17:29:10.050]                     is.null <- base::is.null
[17:29:10.050]                     muffled <- FALSE
[17:29:10.050]                     if (inherits(cond, "message")) {
[17:29:10.050]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:10.050]                       if (muffled) 
[17:29:10.050]                         invokeRestart("muffleMessage")
[17:29:10.050]                     }
[17:29:10.050]                     else if (inherits(cond, "warning")) {
[17:29:10.050]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:10.050]                       if (muffled) 
[17:29:10.050]                         invokeRestart("muffleWarning")
[17:29:10.050]                     }
[17:29:10.050]                     else if (inherits(cond, "condition")) {
[17:29:10.050]                       if (!is.null(pattern)) {
[17:29:10.050]                         computeRestarts <- base::computeRestarts
[17:29:10.050]                         grepl <- base::grepl
[17:29:10.050]                         restarts <- computeRestarts(cond)
[17:29:10.050]                         for (restart in restarts) {
[17:29:10.050]                           name <- restart$name
[17:29:10.050]                           if (is.null(name)) 
[17:29:10.050]                             next
[17:29:10.050]                           if (!grepl(pattern, name)) 
[17:29:10.050]                             next
[17:29:10.050]                           invokeRestart(restart)
[17:29:10.050]                           muffled <- TRUE
[17:29:10.050]                           break
[17:29:10.050]                         }
[17:29:10.050]                       }
[17:29:10.050]                     }
[17:29:10.050]                     invisible(muffled)
[17:29:10.050]                   }
[17:29:10.050]                   muffleCondition(cond)
[17:29:10.050]                 })
[17:29:10.050]             }))
[17:29:10.050]             future::FutureResult(value = ...future.value$value, 
[17:29:10.050]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:10.050]                   ...future.rng), globalenv = if (FALSE) 
[17:29:10.050]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:10.050]                     ...future.globalenv.names))
[17:29:10.050]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:10.050]         }, condition = base::local({
[17:29:10.050]             c <- base::c
[17:29:10.050]             inherits <- base::inherits
[17:29:10.050]             invokeRestart <- base::invokeRestart
[17:29:10.050]             length <- base::length
[17:29:10.050]             list <- base::list
[17:29:10.050]             seq.int <- base::seq.int
[17:29:10.050]             signalCondition <- base::signalCondition
[17:29:10.050]             sys.calls <- base::sys.calls
[17:29:10.050]             `[[` <- base::`[[`
[17:29:10.050]             `+` <- base::`+`
[17:29:10.050]             `<<-` <- base::`<<-`
[17:29:10.050]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:10.050]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:10.050]                   3L)]
[17:29:10.050]             }
[17:29:10.050]             function(cond) {
[17:29:10.050]                 is_error <- inherits(cond, "error")
[17:29:10.050]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:10.050]                   NULL)
[17:29:10.050]                 if (is_error) {
[17:29:10.050]                   sessionInformation <- function() {
[17:29:10.050]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:10.050]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:10.050]                       search = base::search(), system = base::Sys.info())
[17:29:10.050]                   }
[17:29:10.050]                   ...future.conditions[[length(...future.conditions) + 
[17:29:10.050]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:10.050]                     cond$call), session = sessionInformation(), 
[17:29:10.050]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:10.050]                   signalCondition(cond)
[17:29:10.050]                 }
[17:29:10.050]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:10.050]                 "immediateCondition"))) {
[17:29:10.050]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:10.050]                   ...future.conditions[[length(...future.conditions) + 
[17:29:10.050]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:10.050]                   if (TRUE && !signal) {
[17:29:10.050]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:10.050]                     {
[17:29:10.050]                       inherits <- base::inherits
[17:29:10.050]                       invokeRestart <- base::invokeRestart
[17:29:10.050]                       is.null <- base::is.null
[17:29:10.050]                       muffled <- FALSE
[17:29:10.050]                       if (inherits(cond, "message")) {
[17:29:10.050]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:10.050]                         if (muffled) 
[17:29:10.050]                           invokeRestart("muffleMessage")
[17:29:10.050]                       }
[17:29:10.050]                       else if (inherits(cond, "warning")) {
[17:29:10.050]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:10.050]                         if (muffled) 
[17:29:10.050]                           invokeRestart("muffleWarning")
[17:29:10.050]                       }
[17:29:10.050]                       else if (inherits(cond, "condition")) {
[17:29:10.050]                         if (!is.null(pattern)) {
[17:29:10.050]                           computeRestarts <- base::computeRestarts
[17:29:10.050]                           grepl <- base::grepl
[17:29:10.050]                           restarts <- computeRestarts(cond)
[17:29:10.050]                           for (restart in restarts) {
[17:29:10.050]                             name <- restart$name
[17:29:10.050]                             if (is.null(name)) 
[17:29:10.050]                               next
[17:29:10.050]                             if (!grepl(pattern, name)) 
[17:29:10.050]                               next
[17:29:10.050]                             invokeRestart(restart)
[17:29:10.050]                             muffled <- TRUE
[17:29:10.050]                             break
[17:29:10.050]                           }
[17:29:10.050]                         }
[17:29:10.050]                       }
[17:29:10.050]                       invisible(muffled)
[17:29:10.050]                     }
[17:29:10.050]                     muffleCondition(cond, pattern = "^muffle")
[17:29:10.050]                   }
[17:29:10.050]                 }
[17:29:10.050]                 else {
[17:29:10.050]                   if (TRUE) {
[17:29:10.050]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:10.050]                     {
[17:29:10.050]                       inherits <- base::inherits
[17:29:10.050]                       invokeRestart <- base::invokeRestart
[17:29:10.050]                       is.null <- base::is.null
[17:29:10.050]                       muffled <- FALSE
[17:29:10.050]                       if (inherits(cond, "message")) {
[17:29:10.050]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:10.050]                         if (muffled) 
[17:29:10.050]                           invokeRestart("muffleMessage")
[17:29:10.050]                       }
[17:29:10.050]                       else if (inherits(cond, "warning")) {
[17:29:10.050]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:10.050]                         if (muffled) 
[17:29:10.050]                           invokeRestart("muffleWarning")
[17:29:10.050]                       }
[17:29:10.050]                       else if (inherits(cond, "condition")) {
[17:29:10.050]                         if (!is.null(pattern)) {
[17:29:10.050]                           computeRestarts <- base::computeRestarts
[17:29:10.050]                           grepl <- base::grepl
[17:29:10.050]                           restarts <- computeRestarts(cond)
[17:29:10.050]                           for (restart in restarts) {
[17:29:10.050]                             name <- restart$name
[17:29:10.050]                             if (is.null(name)) 
[17:29:10.050]                               next
[17:29:10.050]                             if (!grepl(pattern, name)) 
[17:29:10.050]                               next
[17:29:10.050]                             invokeRestart(restart)
[17:29:10.050]                             muffled <- TRUE
[17:29:10.050]                             break
[17:29:10.050]                           }
[17:29:10.050]                         }
[17:29:10.050]                       }
[17:29:10.050]                       invisible(muffled)
[17:29:10.050]                     }
[17:29:10.050]                     muffleCondition(cond, pattern = "^muffle")
[17:29:10.050]                   }
[17:29:10.050]                 }
[17:29:10.050]             }
[17:29:10.050]         }))
[17:29:10.050]     }, error = function(ex) {
[17:29:10.050]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:10.050]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:10.050]                 ...future.rng), started = ...future.startTime, 
[17:29:10.050]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:10.050]             version = "1.8"), class = "FutureResult")
[17:29:10.050]     }, finally = {
[17:29:10.050]         if (!identical(...future.workdir, getwd())) 
[17:29:10.050]             setwd(...future.workdir)
[17:29:10.050]         {
[17:29:10.050]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:10.050]                 ...future.oldOptions$nwarnings <- NULL
[17:29:10.050]             }
[17:29:10.050]             base::options(...future.oldOptions)
[17:29:10.050]             if (.Platform$OS.type == "windows") {
[17:29:10.050]                 old_names <- names(...future.oldEnvVars)
[17:29:10.050]                 envs <- base::Sys.getenv()
[17:29:10.050]                 names <- names(envs)
[17:29:10.050]                 common <- intersect(names, old_names)
[17:29:10.050]                 added <- setdiff(names, old_names)
[17:29:10.050]                 removed <- setdiff(old_names, names)
[17:29:10.050]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:10.050]                   envs[common]]
[17:29:10.050]                 NAMES <- toupper(changed)
[17:29:10.050]                 args <- list()
[17:29:10.050]                 for (kk in seq_along(NAMES)) {
[17:29:10.050]                   name <- changed[[kk]]
[17:29:10.050]                   NAME <- NAMES[[kk]]
[17:29:10.050]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:10.050]                     next
[17:29:10.050]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:10.050]                 }
[17:29:10.050]                 NAMES <- toupper(added)
[17:29:10.050]                 for (kk in seq_along(NAMES)) {
[17:29:10.050]                   name <- added[[kk]]
[17:29:10.050]                   NAME <- NAMES[[kk]]
[17:29:10.050]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:10.050]                     next
[17:29:10.050]                   args[[name]] <- ""
[17:29:10.050]                 }
[17:29:10.050]                 NAMES <- toupper(removed)
[17:29:10.050]                 for (kk in seq_along(NAMES)) {
[17:29:10.050]                   name <- removed[[kk]]
[17:29:10.050]                   NAME <- NAMES[[kk]]
[17:29:10.050]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:10.050]                     next
[17:29:10.050]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:10.050]                 }
[17:29:10.050]                 if (length(args) > 0) 
[17:29:10.050]                   base::do.call(base::Sys.setenv, args = args)
[17:29:10.050]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:10.050]             }
[17:29:10.050]             else {
[17:29:10.050]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:10.050]             }
[17:29:10.050]             {
[17:29:10.050]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:10.050]                   0L) {
[17:29:10.050]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:10.050]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:10.050]                   base::options(opts)
[17:29:10.050]                 }
[17:29:10.050]                 {
[17:29:10.050]                   {
[17:29:10.050]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:10.050]                     NULL
[17:29:10.050]                   }
[17:29:10.050]                   options(future.plan = NULL)
[17:29:10.050]                   if (is.na(NA_character_)) 
[17:29:10.050]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:10.050]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:10.050]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:10.050]                     .init = FALSE)
[17:29:10.050]                 }
[17:29:10.050]             }
[17:29:10.050]         }
[17:29:10.050]     })
[17:29:10.050]     if (TRUE) {
[17:29:10.050]         base::sink(type = "output", split = FALSE)
[17:29:10.050]         if (TRUE) {
[17:29:10.050]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:10.050]         }
[17:29:10.050]         else {
[17:29:10.050]             ...future.result["stdout"] <- base::list(NULL)
[17:29:10.050]         }
[17:29:10.050]         base::close(...future.stdout)
[17:29:10.050]         ...future.stdout <- NULL
[17:29:10.050]     }
[17:29:10.050]     ...future.result$conditions <- ...future.conditions
[17:29:10.050]     ...future.result$finished <- base::Sys.time()
[17:29:10.050]     ...future.result
[17:29:10.050] }
[17:29:10.060] MultisessionFuture started
[17:29:10.060] - Launch lazy future ... done
[17:29:10.060] run() for 'MultisessionFuture' ... done
[17:29:10.060] getGlobalsAndPackages() ...
[17:29:10.061] Searching for globals...
[17:29:10.062] - globals found: [3] '{', 'Sys.sleep', 'list'
[17:29:10.062] Searching for globals ... DONE
[17:29:10.063] Resolving globals: FALSE
[17:29:10.063] 
[17:29:10.063] 
[17:29:10.064] getGlobalsAndPackages() ... DONE
- w/ exception ...
[17:29:10.064] getGlobalsAndPackages() ...
[17:29:10.064] Searching for globals...
[17:29:10.065] - globals found: [2] 'list', 'stop'
[17:29:10.065] Searching for globals ... DONE
[17:29:10.065] Resolving globals: FALSE
[17:29:10.066] 
[17:29:10.066] 
[17:29:10.066] getGlobalsAndPackages() ... DONE
[17:29:10.067] run() for 'Future' ...
[17:29:10.067] - state: 'created'
[17:29:10.067] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:10.083] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:10.083] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:10.084]   - Field: 'node'
[17:29:10.084]   - Field: 'label'
[17:29:10.084]   - Field: 'local'
[17:29:10.084]   - Field: 'owner'
[17:29:10.084]   - Field: 'envir'
[17:29:10.085]   - Field: 'workers'
[17:29:10.085]   - Field: 'packages'
[17:29:10.085]   - Field: 'gc'
[17:29:10.085]   - Field: 'conditions'
[17:29:10.085]   - Field: 'persistent'
[17:29:10.085]   - Field: 'expr'
[17:29:10.086]   - Field: 'uuid'
[17:29:10.086]   - Field: 'seed'
[17:29:10.086]   - Field: 'version'
[17:29:10.086]   - Field: 'result'
[17:29:10.086]   - Field: 'asynchronous'
[17:29:10.087]   - Field: 'calls'
[17:29:10.087]   - Field: 'globals'
[17:29:10.087]   - Field: 'stdout'
[17:29:10.087]   - Field: 'earlySignal'
[17:29:10.087]   - Field: 'lazy'
[17:29:10.087]   - Field: 'state'
[17:29:10.088] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:10.088] - Launch lazy future ...
[17:29:10.088] Packages needed by the future expression (n = 0): <none>
[17:29:10.088] Packages needed by future strategies (n = 0): <none>
[17:29:10.089] {
[17:29:10.089]     {
[17:29:10.089]         {
[17:29:10.089]             ...future.startTime <- base::Sys.time()
[17:29:10.089]             {
[17:29:10.089]                 {
[17:29:10.089]                   {
[17:29:10.089]                     {
[17:29:10.089]                       base::local({
[17:29:10.089]                         has_future <- base::requireNamespace("future", 
[17:29:10.089]                           quietly = TRUE)
[17:29:10.089]                         if (has_future) {
[17:29:10.089]                           ns <- base::getNamespace("future")
[17:29:10.089]                           version <- ns[[".package"]][["version"]]
[17:29:10.089]                           if (is.null(version)) 
[17:29:10.089]                             version <- utils::packageVersion("future")
[17:29:10.089]                         }
[17:29:10.089]                         else {
[17:29:10.089]                           version <- NULL
[17:29:10.089]                         }
[17:29:10.089]                         if (!has_future || version < "1.8.0") {
[17:29:10.089]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:10.089]                             "", base::R.version$version.string), 
[17:29:10.089]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:10.089]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:10.089]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:10.089]                               "release", "version")], collapse = " "), 
[17:29:10.089]                             hostname = base::Sys.info()[["nodename"]])
[17:29:10.089]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:10.089]                             info)
[17:29:10.089]                           info <- base::paste(info, collapse = "; ")
[17:29:10.089]                           if (!has_future) {
[17:29:10.089]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:10.089]                               info)
[17:29:10.089]                           }
[17:29:10.089]                           else {
[17:29:10.089]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:10.089]                               info, version)
[17:29:10.089]                           }
[17:29:10.089]                           base::stop(msg)
[17:29:10.089]                         }
[17:29:10.089]                       })
[17:29:10.089]                     }
[17:29:10.089]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:10.089]                     base::options(mc.cores = 1L)
[17:29:10.089]                   }
[17:29:10.089]                   ...future.strategy.old <- future::plan("list")
[17:29:10.089]                   options(future.plan = NULL)
[17:29:10.089]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:10.089]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:10.089]                 }
[17:29:10.089]                 ...future.workdir <- getwd()
[17:29:10.089]             }
[17:29:10.089]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:10.089]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:10.089]         }
[17:29:10.089]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:10.089]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:10.089]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:10.089]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:10.089]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:10.089]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:10.089]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:10.089]             base::names(...future.oldOptions))
[17:29:10.089]     }
[17:29:10.089]     if (FALSE) {
[17:29:10.089]     }
[17:29:10.089]     else {
[17:29:10.089]         if (TRUE) {
[17:29:10.089]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:10.089]                 open = "w")
[17:29:10.089]         }
[17:29:10.089]         else {
[17:29:10.089]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:10.089]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:10.089]         }
[17:29:10.089]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:10.089]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:10.089]             base::sink(type = "output", split = FALSE)
[17:29:10.089]             base::close(...future.stdout)
[17:29:10.089]         }, add = TRUE)
[17:29:10.089]     }
[17:29:10.089]     ...future.frame <- base::sys.nframe()
[17:29:10.089]     ...future.conditions <- base::list()
[17:29:10.089]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:10.089]     if (FALSE) {
[17:29:10.089]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:10.089]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:10.089]     }
[17:29:10.089]     ...future.result <- base::tryCatch({
[17:29:10.089]         base::withCallingHandlers({
[17:29:10.089]             ...future.value <- base::withVisible(base::local({
[17:29:10.089]                 ...future.makeSendCondition <- base::local({
[17:29:10.089]                   sendCondition <- NULL
[17:29:10.089]                   function(frame = 1L) {
[17:29:10.089]                     if (is.function(sendCondition)) 
[17:29:10.089]                       return(sendCondition)
[17:29:10.089]                     ns <- getNamespace("parallel")
[17:29:10.089]                     if (exists("sendData", mode = "function", 
[17:29:10.089]                       envir = ns)) {
[17:29:10.089]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:10.089]                         envir = ns)
[17:29:10.089]                       envir <- sys.frame(frame)
[17:29:10.089]                       master <- NULL
[17:29:10.089]                       while (!identical(envir, .GlobalEnv) && 
[17:29:10.089]                         !identical(envir, emptyenv())) {
[17:29:10.089]                         if (exists("master", mode = "list", envir = envir, 
[17:29:10.089]                           inherits = FALSE)) {
[17:29:10.089]                           master <- get("master", mode = "list", 
[17:29:10.089]                             envir = envir, inherits = FALSE)
[17:29:10.089]                           if (inherits(master, c("SOCKnode", 
[17:29:10.089]                             "SOCK0node"))) {
[17:29:10.089]                             sendCondition <<- function(cond) {
[17:29:10.089]                               data <- list(type = "VALUE", value = cond, 
[17:29:10.089]                                 success = TRUE)
[17:29:10.089]                               parallel_sendData(master, data)
[17:29:10.089]                             }
[17:29:10.089]                             return(sendCondition)
[17:29:10.089]                           }
[17:29:10.089]                         }
[17:29:10.089]                         frame <- frame + 1L
[17:29:10.089]                         envir <- sys.frame(frame)
[17:29:10.089]                       }
[17:29:10.089]                     }
[17:29:10.089]                     sendCondition <<- function(cond) NULL
[17:29:10.089]                   }
[17:29:10.089]                 })
[17:29:10.089]                 withCallingHandlers({
[17:29:10.089]                   list(a = 1, b = 42L, c = stop("Nah!"))
[17:29:10.089]                 }, immediateCondition = function(cond) {
[17:29:10.089]                   sendCondition <- ...future.makeSendCondition()
[17:29:10.089]                   sendCondition(cond)
[17:29:10.089]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:10.089]                   {
[17:29:10.089]                     inherits <- base::inherits
[17:29:10.089]                     invokeRestart <- base::invokeRestart
[17:29:10.089]                     is.null <- base::is.null
[17:29:10.089]                     muffled <- FALSE
[17:29:10.089]                     if (inherits(cond, "message")) {
[17:29:10.089]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:10.089]                       if (muffled) 
[17:29:10.089]                         invokeRestart("muffleMessage")
[17:29:10.089]                     }
[17:29:10.089]                     else if (inherits(cond, "warning")) {
[17:29:10.089]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:10.089]                       if (muffled) 
[17:29:10.089]                         invokeRestart("muffleWarning")
[17:29:10.089]                     }
[17:29:10.089]                     else if (inherits(cond, "condition")) {
[17:29:10.089]                       if (!is.null(pattern)) {
[17:29:10.089]                         computeRestarts <- base::computeRestarts
[17:29:10.089]                         grepl <- base::grepl
[17:29:10.089]                         restarts <- computeRestarts(cond)
[17:29:10.089]                         for (restart in restarts) {
[17:29:10.089]                           name <- restart$name
[17:29:10.089]                           if (is.null(name)) 
[17:29:10.089]                             next
[17:29:10.089]                           if (!grepl(pattern, name)) 
[17:29:10.089]                             next
[17:29:10.089]                           invokeRestart(restart)
[17:29:10.089]                           muffled <- TRUE
[17:29:10.089]                           break
[17:29:10.089]                         }
[17:29:10.089]                       }
[17:29:10.089]                     }
[17:29:10.089]                     invisible(muffled)
[17:29:10.089]                   }
[17:29:10.089]                   muffleCondition(cond)
[17:29:10.089]                 })
[17:29:10.089]             }))
[17:29:10.089]             future::FutureResult(value = ...future.value$value, 
[17:29:10.089]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:10.089]                   ...future.rng), globalenv = if (FALSE) 
[17:29:10.089]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:10.089]                     ...future.globalenv.names))
[17:29:10.089]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:10.089]         }, condition = base::local({
[17:29:10.089]             c <- base::c
[17:29:10.089]             inherits <- base::inherits
[17:29:10.089]             invokeRestart <- base::invokeRestart
[17:29:10.089]             length <- base::length
[17:29:10.089]             list <- base::list
[17:29:10.089]             seq.int <- base::seq.int
[17:29:10.089]             signalCondition <- base::signalCondition
[17:29:10.089]             sys.calls <- base::sys.calls
[17:29:10.089]             `[[` <- base::`[[`
[17:29:10.089]             `+` <- base::`+`
[17:29:10.089]             `<<-` <- base::`<<-`
[17:29:10.089]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:10.089]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:10.089]                   3L)]
[17:29:10.089]             }
[17:29:10.089]             function(cond) {
[17:29:10.089]                 is_error <- inherits(cond, "error")
[17:29:10.089]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:10.089]                   NULL)
[17:29:10.089]                 if (is_error) {
[17:29:10.089]                   sessionInformation <- function() {
[17:29:10.089]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:10.089]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:10.089]                       search = base::search(), system = base::Sys.info())
[17:29:10.089]                   }
[17:29:10.089]                   ...future.conditions[[length(...future.conditions) + 
[17:29:10.089]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:10.089]                     cond$call), session = sessionInformation(), 
[17:29:10.089]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:10.089]                   signalCondition(cond)
[17:29:10.089]                 }
[17:29:10.089]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:10.089]                 "immediateCondition"))) {
[17:29:10.089]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:10.089]                   ...future.conditions[[length(...future.conditions) + 
[17:29:10.089]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:10.089]                   if (TRUE && !signal) {
[17:29:10.089]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:10.089]                     {
[17:29:10.089]                       inherits <- base::inherits
[17:29:10.089]                       invokeRestart <- base::invokeRestart
[17:29:10.089]                       is.null <- base::is.null
[17:29:10.089]                       muffled <- FALSE
[17:29:10.089]                       if (inherits(cond, "message")) {
[17:29:10.089]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:10.089]                         if (muffled) 
[17:29:10.089]                           invokeRestart("muffleMessage")
[17:29:10.089]                       }
[17:29:10.089]                       else if (inherits(cond, "warning")) {
[17:29:10.089]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:10.089]                         if (muffled) 
[17:29:10.089]                           invokeRestart("muffleWarning")
[17:29:10.089]                       }
[17:29:10.089]                       else if (inherits(cond, "condition")) {
[17:29:10.089]                         if (!is.null(pattern)) {
[17:29:10.089]                           computeRestarts <- base::computeRestarts
[17:29:10.089]                           grepl <- base::grepl
[17:29:10.089]                           restarts <- computeRestarts(cond)
[17:29:10.089]                           for (restart in restarts) {
[17:29:10.089]                             name <- restart$name
[17:29:10.089]                             if (is.null(name)) 
[17:29:10.089]                               next
[17:29:10.089]                             if (!grepl(pattern, name)) 
[17:29:10.089]                               next
[17:29:10.089]                             invokeRestart(restart)
[17:29:10.089]                             muffled <- TRUE
[17:29:10.089]                             break
[17:29:10.089]                           }
[17:29:10.089]                         }
[17:29:10.089]                       }
[17:29:10.089]                       invisible(muffled)
[17:29:10.089]                     }
[17:29:10.089]                     muffleCondition(cond, pattern = "^muffle")
[17:29:10.089]                   }
[17:29:10.089]                 }
[17:29:10.089]                 else {
[17:29:10.089]                   if (TRUE) {
[17:29:10.089]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:10.089]                     {
[17:29:10.089]                       inherits <- base::inherits
[17:29:10.089]                       invokeRestart <- base::invokeRestart
[17:29:10.089]                       is.null <- base::is.null
[17:29:10.089]                       muffled <- FALSE
[17:29:10.089]                       if (inherits(cond, "message")) {
[17:29:10.089]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:10.089]                         if (muffled) 
[17:29:10.089]                           invokeRestart("muffleMessage")
[17:29:10.089]                       }
[17:29:10.089]                       else if (inherits(cond, "warning")) {
[17:29:10.089]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:10.089]                         if (muffled) 
[17:29:10.089]                           invokeRestart("muffleWarning")
[17:29:10.089]                       }
[17:29:10.089]                       else if (inherits(cond, "condition")) {
[17:29:10.089]                         if (!is.null(pattern)) {
[17:29:10.089]                           computeRestarts <- base::computeRestarts
[17:29:10.089]                           grepl <- base::grepl
[17:29:10.089]                           restarts <- computeRestarts(cond)
[17:29:10.089]                           for (restart in restarts) {
[17:29:10.089]                             name <- restart$name
[17:29:10.089]                             if (is.null(name)) 
[17:29:10.089]                               next
[17:29:10.089]                             if (!grepl(pattern, name)) 
[17:29:10.089]                               next
[17:29:10.089]                             invokeRestart(restart)
[17:29:10.089]                             muffled <- TRUE
[17:29:10.089]                             break
[17:29:10.089]                           }
[17:29:10.089]                         }
[17:29:10.089]                       }
[17:29:10.089]                       invisible(muffled)
[17:29:10.089]                     }
[17:29:10.089]                     muffleCondition(cond, pattern = "^muffle")
[17:29:10.089]                   }
[17:29:10.089]                 }
[17:29:10.089]             }
[17:29:10.089]         }))
[17:29:10.089]     }, error = function(ex) {
[17:29:10.089]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:10.089]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:10.089]                 ...future.rng), started = ...future.startTime, 
[17:29:10.089]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:10.089]             version = "1.8"), class = "FutureResult")
[17:29:10.089]     }, finally = {
[17:29:10.089]         if (!identical(...future.workdir, getwd())) 
[17:29:10.089]             setwd(...future.workdir)
[17:29:10.089]         {
[17:29:10.089]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:10.089]                 ...future.oldOptions$nwarnings <- NULL
[17:29:10.089]             }
[17:29:10.089]             base::options(...future.oldOptions)
[17:29:10.089]             if (.Platform$OS.type == "windows") {
[17:29:10.089]                 old_names <- names(...future.oldEnvVars)
[17:29:10.089]                 envs <- base::Sys.getenv()
[17:29:10.089]                 names <- names(envs)
[17:29:10.089]                 common <- intersect(names, old_names)
[17:29:10.089]                 added <- setdiff(names, old_names)
[17:29:10.089]                 removed <- setdiff(old_names, names)
[17:29:10.089]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:10.089]                   envs[common]]
[17:29:10.089]                 NAMES <- toupper(changed)
[17:29:10.089]                 args <- list()
[17:29:10.089]                 for (kk in seq_along(NAMES)) {
[17:29:10.089]                   name <- changed[[kk]]
[17:29:10.089]                   NAME <- NAMES[[kk]]
[17:29:10.089]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:10.089]                     next
[17:29:10.089]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:10.089]                 }
[17:29:10.089]                 NAMES <- toupper(added)
[17:29:10.089]                 for (kk in seq_along(NAMES)) {
[17:29:10.089]                   name <- added[[kk]]
[17:29:10.089]                   NAME <- NAMES[[kk]]
[17:29:10.089]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:10.089]                     next
[17:29:10.089]                   args[[name]] <- ""
[17:29:10.089]                 }
[17:29:10.089]                 NAMES <- toupper(removed)
[17:29:10.089]                 for (kk in seq_along(NAMES)) {
[17:29:10.089]                   name <- removed[[kk]]
[17:29:10.089]                   NAME <- NAMES[[kk]]
[17:29:10.089]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:10.089]                     next
[17:29:10.089]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:10.089]                 }
[17:29:10.089]                 if (length(args) > 0) 
[17:29:10.089]                   base::do.call(base::Sys.setenv, args = args)
[17:29:10.089]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:10.089]             }
[17:29:10.089]             else {
[17:29:10.089]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:10.089]             }
[17:29:10.089]             {
[17:29:10.089]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:10.089]                   0L) {
[17:29:10.089]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:10.089]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:10.089]                   base::options(opts)
[17:29:10.089]                 }
[17:29:10.089]                 {
[17:29:10.089]                   {
[17:29:10.089]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:10.089]                     NULL
[17:29:10.089]                   }
[17:29:10.089]                   options(future.plan = NULL)
[17:29:10.089]                   if (is.na(NA_character_)) 
[17:29:10.089]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:10.089]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:10.089]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:10.089]                     .init = FALSE)
[17:29:10.089]                 }
[17:29:10.089]             }
[17:29:10.089]         }
[17:29:10.089]     })
[17:29:10.089]     if (TRUE) {
[17:29:10.089]         base::sink(type = "output", split = FALSE)
[17:29:10.089]         if (TRUE) {
[17:29:10.089]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:10.089]         }
[17:29:10.089]         else {
[17:29:10.089]             ...future.result["stdout"] <- base::list(NULL)
[17:29:10.089]         }
[17:29:10.089]         base::close(...future.stdout)
[17:29:10.089]         ...future.stdout <- NULL
[17:29:10.089]     }
[17:29:10.089]     ...future.result$conditions <- ...future.conditions
[17:29:10.089]     ...future.result$finished <- base::Sys.time()
[17:29:10.089]     ...future.result
[17:29:10.089] }
[17:29:10.230] MultisessionFuture started
[17:29:10.230] - Launch lazy future ... done
[17:29:10.230] run() for 'MultisessionFuture' ... done
[17:29:10.231] getGlobalsAndPackages() ...
[17:29:10.231] Searching for globals...
[17:29:10.232] - globals found: [2] 'list', 'stop'
[17:29:10.233] Searching for globals ... DONE
[17:29:10.233] Resolving globals: FALSE
[17:29:10.234] 
[17:29:10.234] 
[17:29:10.234] getGlobalsAndPackages() ... DONE
- result = FALSE, recursive = -1 ... DONE
- result = FALSE, recursive = 0 ...
[17:29:10.235] getGlobalsAndPackages() ...
[17:29:10.235] Searching for globals...
[17:29:10.241] - globals found: [3] '{', 'Sys.sleep', 'list'
[17:29:10.242] Searching for globals ... DONE
[17:29:10.242] Resolving globals: FALSE
[17:29:10.242] 
[17:29:10.243] 
[17:29:10.243] getGlobalsAndPackages() ... DONE
[17:29:10.243] run() for 'Future' ...
[17:29:10.244] - state: 'created'
[17:29:10.244] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:10.264] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:10.265] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:10.265]   - Field: 'node'
[17:29:10.266]   - Field: 'label'
[17:29:10.266]   - Field: 'local'
[17:29:10.266]   - Field: 'owner'
[17:29:10.266]   - Field: 'envir'
[17:29:10.267]   - Field: 'workers'
[17:29:10.267]   - Field: 'packages'
[17:29:10.267]   - Field: 'gc'
[17:29:10.268]   - Field: 'conditions'
[17:29:10.268]   - Field: 'persistent'
[17:29:10.268]   - Field: 'expr'
[17:29:10.268]   - Field: 'uuid'
[17:29:10.269]   - Field: 'seed'
[17:29:10.269]   - Field: 'version'
[17:29:10.269]   - Field: 'result'
[17:29:10.270]   - Field: 'asynchronous'
[17:29:10.270]   - Field: 'calls'
[17:29:10.270]   - Field: 'globals'
[17:29:10.270]   - Field: 'stdout'
[17:29:10.271]   - Field: 'earlySignal'
[17:29:10.271]   - Field: 'lazy'
[17:29:10.271]   - Field: 'state'
[17:29:10.272] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:10.272] - Launch lazy future ...
[17:29:10.272] Packages needed by the future expression (n = 0): <none>
[17:29:10.273] Packages needed by future strategies (n = 0): <none>
[17:29:10.274] {
[17:29:10.274]     {
[17:29:10.274]         {
[17:29:10.274]             ...future.startTime <- base::Sys.time()
[17:29:10.274]             {
[17:29:10.274]                 {
[17:29:10.274]                   {
[17:29:10.274]                     {
[17:29:10.274]                       base::local({
[17:29:10.274]                         has_future <- base::requireNamespace("future", 
[17:29:10.274]                           quietly = TRUE)
[17:29:10.274]                         if (has_future) {
[17:29:10.274]                           ns <- base::getNamespace("future")
[17:29:10.274]                           version <- ns[[".package"]][["version"]]
[17:29:10.274]                           if (is.null(version)) 
[17:29:10.274]                             version <- utils::packageVersion("future")
[17:29:10.274]                         }
[17:29:10.274]                         else {
[17:29:10.274]                           version <- NULL
[17:29:10.274]                         }
[17:29:10.274]                         if (!has_future || version < "1.8.0") {
[17:29:10.274]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:10.274]                             "", base::R.version$version.string), 
[17:29:10.274]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:10.274]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:10.274]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:10.274]                               "release", "version")], collapse = " "), 
[17:29:10.274]                             hostname = base::Sys.info()[["nodename"]])
[17:29:10.274]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:10.274]                             info)
[17:29:10.274]                           info <- base::paste(info, collapse = "; ")
[17:29:10.274]                           if (!has_future) {
[17:29:10.274]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:10.274]                               info)
[17:29:10.274]                           }
[17:29:10.274]                           else {
[17:29:10.274]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:10.274]                               info, version)
[17:29:10.274]                           }
[17:29:10.274]                           base::stop(msg)
[17:29:10.274]                         }
[17:29:10.274]                       })
[17:29:10.274]                     }
[17:29:10.274]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:10.274]                     base::options(mc.cores = 1L)
[17:29:10.274]                   }
[17:29:10.274]                   ...future.strategy.old <- future::plan("list")
[17:29:10.274]                   options(future.plan = NULL)
[17:29:10.274]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:10.274]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:10.274]                 }
[17:29:10.274]                 ...future.workdir <- getwd()
[17:29:10.274]             }
[17:29:10.274]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:10.274]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:10.274]         }
[17:29:10.274]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:10.274]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:10.274]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:10.274]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:10.274]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:10.274]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:10.274]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:10.274]             base::names(...future.oldOptions))
[17:29:10.274]     }
[17:29:10.274]     if (FALSE) {
[17:29:10.274]     }
[17:29:10.274]     else {
[17:29:10.274]         if (TRUE) {
[17:29:10.274]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:10.274]                 open = "w")
[17:29:10.274]         }
[17:29:10.274]         else {
[17:29:10.274]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:10.274]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:10.274]         }
[17:29:10.274]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:10.274]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:10.274]             base::sink(type = "output", split = FALSE)
[17:29:10.274]             base::close(...future.stdout)
[17:29:10.274]         }, add = TRUE)
[17:29:10.274]     }
[17:29:10.274]     ...future.frame <- base::sys.nframe()
[17:29:10.274]     ...future.conditions <- base::list()
[17:29:10.274]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:10.274]     if (FALSE) {
[17:29:10.274]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:10.274]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:10.274]     }
[17:29:10.274]     ...future.result <- base::tryCatch({
[17:29:10.274]         base::withCallingHandlers({
[17:29:10.274]             ...future.value <- base::withVisible(base::local({
[17:29:10.274]                 ...future.makeSendCondition <- base::local({
[17:29:10.274]                   sendCondition <- NULL
[17:29:10.274]                   function(frame = 1L) {
[17:29:10.274]                     if (is.function(sendCondition)) 
[17:29:10.274]                       return(sendCondition)
[17:29:10.274]                     ns <- getNamespace("parallel")
[17:29:10.274]                     if (exists("sendData", mode = "function", 
[17:29:10.274]                       envir = ns)) {
[17:29:10.274]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:10.274]                         envir = ns)
[17:29:10.274]                       envir <- sys.frame(frame)
[17:29:10.274]                       master <- NULL
[17:29:10.274]                       while (!identical(envir, .GlobalEnv) && 
[17:29:10.274]                         !identical(envir, emptyenv())) {
[17:29:10.274]                         if (exists("master", mode = "list", envir = envir, 
[17:29:10.274]                           inherits = FALSE)) {
[17:29:10.274]                           master <- get("master", mode = "list", 
[17:29:10.274]                             envir = envir, inherits = FALSE)
[17:29:10.274]                           if (inherits(master, c("SOCKnode", 
[17:29:10.274]                             "SOCK0node"))) {
[17:29:10.274]                             sendCondition <<- function(cond) {
[17:29:10.274]                               data <- list(type = "VALUE", value = cond, 
[17:29:10.274]                                 success = TRUE)
[17:29:10.274]                               parallel_sendData(master, data)
[17:29:10.274]                             }
[17:29:10.274]                             return(sendCondition)
[17:29:10.274]                           }
[17:29:10.274]                         }
[17:29:10.274]                         frame <- frame + 1L
[17:29:10.274]                         envir <- sys.frame(frame)
[17:29:10.274]                       }
[17:29:10.274]                     }
[17:29:10.274]                     sendCondition <<- function(cond) NULL
[17:29:10.274]                   }
[17:29:10.274]                 })
[17:29:10.274]                 withCallingHandlers({
[17:29:10.274]                   {
[17:29:10.274]                     Sys.sleep(0.5)
[17:29:10.274]                     list(a = 1, b = 42L)
[17:29:10.274]                   }
[17:29:10.274]                 }, immediateCondition = function(cond) {
[17:29:10.274]                   sendCondition <- ...future.makeSendCondition()
[17:29:10.274]                   sendCondition(cond)
[17:29:10.274]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:10.274]                   {
[17:29:10.274]                     inherits <- base::inherits
[17:29:10.274]                     invokeRestart <- base::invokeRestart
[17:29:10.274]                     is.null <- base::is.null
[17:29:10.274]                     muffled <- FALSE
[17:29:10.274]                     if (inherits(cond, "message")) {
[17:29:10.274]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:10.274]                       if (muffled) 
[17:29:10.274]                         invokeRestart("muffleMessage")
[17:29:10.274]                     }
[17:29:10.274]                     else if (inherits(cond, "warning")) {
[17:29:10.274]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:10.274]                       if (muffled) 
[17:29:10.274]                         invokeRestart("muffleWarning")
[17:29:10.274]                     }
[17:29:10.274]                     else if (inherits(cond, "condition")) {
[17:29:10.274]                       if (!is.null(pattern)) {
[17:29:10.274]                         computeRestarts <- base::computeRestarts
[17:29:10.274]                         grepl <- base::grepl
[17:29:10.274]                         restarts <- computeRestarts(cond)
[17:29:10.274]                         for (restart in restarts) {
[17:29:10.274]                           name <- restart$name
[17:29:10.274]                           if (is.null(name)) 
[17:29:10.274]                             next
[17:29:10.274]                           if (!grepl(pattern, name)) 
[17:29:10.274]                             next
[17:29:10.274]                           invokeRestart(restart)
[17:29:10.274]                           muffled <- TRUE
[17:29:10.274]                           break
[17:29:10.274]                         }
[17:29:10.274]                       }
[17:29:10.274]                     }
[17:29:10.274]                     invisible(muffled)
[17:29:10.274]                   }
[17:29:10.274]                   muffleCondition(cond)
[17:29:10.274]                 })
[17:29:10.274]             }))
[17:29:10.274]             future::FutureResult(value = ...future.value$value, 
[17:29:10.274]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:10.274]                   ...future.rng), globalenv = if (FALSE) 
[17:29:10.274]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:10.274]                     ...future.globalenv.names))
[17:29:10.274]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:10.274]         }, condition = base::local({
[17:29:10.274]             c <- base::c
[17:29:10.274]             inherits <- base::inherits
[17:29:10.274]             invokeRestart <- base::invokeRestart
[17:29:10.274]             length <- base::length
[17:29:10.274]             list <- base::list
[17:29:10.274]             seq.int <- base::seq.int
[17:29:10.274]             signalCondition <- base::signalCondition
[17:29:10.274]             sys.calls <- base::sys.calls
[17:29:10.274]             `[[` <- base::`[[`
[17:29:10.274]             `+` <- base::`+`
[17:29:10.274]             `<<-` <- base::`<<-`
[17:29:10.274]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:10.274]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:10.274]                   3L)]
[17:29:10.274]             }
[17:29:10.274]             function(cond) {
[17:29:10.274]                 is_error <- inherits(cond, "error")
[17:29:10.274]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:10.274]                   NULL)
[17:29:10.274]                 if (is_error) {
[17:29:10.274]                   sessionInformation <- function() {
[17:29:10.274]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:10.274]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:10.274]                       search = base::search(), system = base::Sys.info())
[17:29:10.274]                   }
[17:29:10.274]                   ...future.conditions[[length(...future.conditions) + 
[17:29:10.274]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:10.274]                     cond$call), session = sessionInformation(), 
[17:29:10.274]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:10.274]                   signalCondition(cond)
[17:29:10.274]                 }
[17:29:10.274]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:10.274]                 "immediateCondition"))) {
[17:29:10.274]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:10.274]                   ...future.conditions[[length(...future.conditions) + 
[17:29:10.274]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:10.274]                   if (TRUE && !signal) {
[17:29:10.274]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:10.274]                     {
[17:29:10.274]                       inherits <- base::inherits
[17:29:10.274]                       invokeRestart <- base::invokeRestart
[17:29:10.274]                       is.null <- base::is.null
[17:29:10.274]                       muffled <- FALSE
[17:29:10.274]                       if (inherits(cond, "message")) {
[17:29:10.274]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:10.274]                         if (muffled) 
[17:29:10.274]                           invokeRestart("muffleMessage")
[17:29:10.274]                       }
[17:29:10.274]                       else if (inherits(cond, "warning")) {
[17:29:10.274]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:10.274]                         if (muffled) 
[17:29:10.274]                           invokeRestart("muffleWarning")
[17:29:10.274]                       }
[17:29:10.274]                       else if (inherits(cond, "condition")) {
[17:29:10.274]                         if (!is.null(pattern)) {
[17:29:10.274]                           computeRestarts <- base::computeRestarts
[17:29:10.274]                           grepl <- base::grepl
[17:29:10.274]                           restarts <- computeRestarts(cond)
[17:29:10.274]                           for (restart in restarts) {
[17:29:10.274]                             name <- restart$name
[17:29:10.274]                             if (is.null(name)) 
[17:29:10.274]                               next
[17:29:10.274]                             if (!grepl(pattern, name)) 
[17:29:10.274]                               next
[17:29:10.274]                             invokeRestart(restart)
[17:29:10.274]                             muffled <- TRUE
[17:29:10.274]                             break
[17:29:10.274]                           }
[17:29:10.274]                         }
[17:29:10.274]                       }
[17:29:10.274]                       invisible(muffled)
[17:29:10.274]                     }
[17:29:10.274]                     muffleCondition(cond, pattern = "^muffle")
[17:29:10.274]                   }
[17:29:10.274]                 }
[17:29:10.274]                 else {
[17:29:10.274]                   if (TRUE) {
[17:29:10.274]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:10.274]                     {
[17:29:10.274]                       inherits <- base::inherits
[17:29:10.274]                       invokeRestart <- base::invokeRestart
[17:29:10.274]                       is.null <- base::is.null
[17:29:10.274]                       muffled <- FALSE
[17:29:10.274]                       if (inherits(cond, "message")) {
[17:29:10.274]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:10.274]                         if (muffled) 
[17:29:10.274]                           invokeRestart("muffleMessage")
[17:29:10.274]                       }
[17:29:10.274]                       else if (inherits(cond, "warning")) {
[17:29:10.274]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:10.274]                         if (muffled) 
[17:29:10.274]                           invokeRestart("muffleWarning")
[17:29:10.274]                       }
[17:29:10.274]                       else if (inherits(cond, "condition")) {
[17:29:10.274]                         if (!is.null(pattern)) {
[17:29:10.274]                           computeRestarts <- base::computeRestarts
[17:29:10.274]                           grepl <- base::grepl
[17:29:10.274]                           restarts <- computeRestarts(cond)
[17:29:10.274]                           for (restart in restarts) {
[17:29:10.274]                             name <- restart$name
[17:29:10.274]                             if (is.null(name)) 
[17:29:10.274]                               next
[17:29:10.274]                             if (!grepl(pattern, name)) 
[17:29:10.274]                               next
[17:29:10.274]                             invokeRestart(restart)
[17:29:10.274]                             muffled <- TRUE
[17:29:10.274]                             break
[17:29:10.274]                           }
[17:29:10.274]                         }
[17:29:10.274]                       }
[17:29:10.274]                       invisible(muffled)
[17:29:10.274]                     }
[17:29:10.274]                     muffleCondition(cond, pattern = "^muffle")
[17:29:10.274]                   }
[17:29:10.274]                 }
[17:29:10.274]             }
[17:29:10.274]         }))
[17:29:10.274]     }, error = function(ex) {
[17:29:10.274]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:10.274]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:10.274]                 ...future.rng), started = ...future.startTime, 
[17:29:10.274]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:10.274]             version = "1.8"), class = "FutureResult")
[17:29:10.274]     }, finally = {
[17:29:10.274]         if (!identical(...future.workdir, getwd())) 
[17:29:10.274]             setwd(...future.workdir)
[17:29:10.274]         {
[17:29:10.274]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:10.274]                 ...future.oldOptions$nwarnings <- NULL
[17:29:10.274]             }
[17:29:10.274]             base::options(...future.oldOptions)
[17:29:10.274]             if (.Platform$OS.type == "windows") {
[17:29:10.274]                 old_names <- names(...future.oldEnvVars)
[17:29:10.274]                 envs <- base::Sys.getenv()
[17:29:10.274]                 names <- names(envs)
[17:29:10.274]                 common <- intersect(names, old_names)
[17:29:10.274]                 added <- setdiff(names, old_names)
[17:29:10.274]                 removed <- setdiff(old_names, names)
[17:29:10.274]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:10.274]                   envs[common]]
[17:29:10.274]                 NAMES <- toupper(changed)
[17:29:10.274]                 args <- list()
[17:29:10.274]                 for (kk in seq_along(NAMES)) {
[17:29:10.274]                   name <- changed[[kk]]
[17:29:10.274]                   NAME <- NAMES[[kk]]
[17:29:10.274]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:10.274]                     next
[17:29:10.274]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:10.274]                 }
[17:29:10.274]                 NAMES <- toupper(added)
[17:29:10.274]                 for (kk in seq_along(NAMES)) {
[17:29:10.274]                   name <- added[[kk]]
[17:29:10.274]                   NAME <- NAMES[[kk]]
[17:29:10.274]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:10.274]                     next
[17:29:10.274]                   args[[name]] <- ""
[17:29:10.274]                 }
[17:29:10.274]                 NAMES <- toupper(removed)
[17:29:10.274]                 for (kk in seq_along(NAMES)) {
[17:29:10.274]                   name <- removed[[kk]]
[17:29:10.274]                   NAME <- NAMES[[kk]]
[17:29:10.274]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:10.274]                     next
[17:29:10.274]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:10.274]                 }
[17:29:10.274]                 if (length(args) > 0) 
[17:29:10.274]                   base::do.call(base::Sys.setenv, args = args)
[17:29:10.274]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:10.274]             }
[17:29:10.274]             else {
[17:29:10.274]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:10.274]             }
[17:29:10.274]             {
[17:29:10.274]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:10.274]                   0L) {
[17:29:10.274]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:10.274]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:10.274]                   base::options(opts)
[17:29:10.274]                 }
[17:29:10.274]                 {
[17:29:10.274]                   {
[17:29:10.274]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:10.274]                     NULL
[17:29:10.274]                   }
[17:29:10.274]                   options(future.plan = NULL)
[17:29:10.274]                   if (is.na(NA_character_)) 
[17:29:10.274]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:10.274]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:10.274]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:10.274]                     .init = FALSE)
[17:29:10.274]                 }
[17:29:10.274]             }
[17:29:10.274]         }
[17:29:10.274]     })
[17:29:10.274]     if (TRUE) {
[17:29:10.274]         base::sink(type = "output", split = FALSE)
[17:29:10.274]         if (TRUE) {
[17:29:10.274]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:10.274]         }
[17:29:10.274]         else {
[17:29:10.274]             ...future.result["stdout"] <- base::list(NULL)
[17:29:10.274]         }
[17:29:10.274]         base::close(...future.stdout)
[17:29:10.274]         ...future.stdout <- NULL
[17:29:10.274]     }
[17:29:10.274]     ...future.result$conditions <- ...future.conditions
[17:29:10.274]     ...future.result$finished <- base::Sys.time()
[17:29:10.274]     ...future.result
[17:29:10.274] }
[17:29:10.282] Poll #1 (0): usedNodes() = 2, workers = 2
[17:29:10.503] receiveMessageFromWorker() for ClusterFuture ...
[17:29:10.504] - Validating connection of MultisessionFuture
[17:29:10.504] - received message: FutureResult
[17:29:10.505] - Received FutureResult
[17:29:10.505] - Erased future from FutureRegistry
[17:29:10.505] result() for ClusterFuture ...
[17:29:10.505] - result already collected: FutureResult
[17:29:10.505] result() for ClusterFuture ... done
[17:29:10.505] signalConditions() ...
[17:29:10.506]  - include = 'immediateCondition'
[17:29:10.506]  - exclude = 
[17:29:10.506]  - resignal = FALSE
[17:29:10.506]  - Number of conditions: 1
[17:29:10.506] signalConditions() ... done
[17:29:10.507] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:10.507] result() for ClusterFuture ...
[17:29:10.507] - result already collected: FutureResult
[17:29:10.507] result() for ClusterFuture ... done
[17:29:10.507] result() for ClusterFuture ...
[17:29:10.507] - result already collected: FutureResult
[17:29:10.508] result() for ClusterFuture ... done
[17:29:10.508] signalConditions() ...
[17:29:10.508]  - include = 'immediateCondition'
[17:29:10.508]  - exclude = 
[17:29:10.508]  - resignal = FALSE
[17:29:10.508]  - Number of conditions: 1
[17:29:10.509] signalConditions() ... done
[17:29:10.510] MultisessionFuture started
[17:29:10.510] - Launch lazy future ... done
[17:29:10.510] run() for 'MultisessionFuture' ... done
[17:29:11.045] receiveMessageFromWorker() for ClusterFuture ...
[17:29:11.045] - Validating connection of MultisessionFuture
[17:29:11.046] - received message: FutureResult
[17:29:11.046] - Received FutureResult
[17:29:11.046] - Erased future from FutureRegistry
[17:29:11.046] result() for ClusterFuture ...
[17:29:11.047] - result already collected: FutureResult
[17:29:11.047] result() for ClusterFuture ... done
[17:29:11.047] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:11.048] A MultisessionFuture was resolved (result was not collected)
[17:29:11.048] getGlobalsAndPackages() ...
[17:29:11.048] Searching for globals...
[17:29:11.050] - globals found: [3] '{', 'Sys.sleep', 'list'
[17:29:11.051] Searching for globals ... DONE
[17:29:11.051] Resolving globals: FALSE
[17:29:11.052] 
[17:29:11.052] 
[17:29:11.052] getGlobalsAndPackages() ... DONE
[17:29:11.053] run() for 'Future' ...
[17:29:11.053] - state: 'created'
[17:29:11.053] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:11.076] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:11.077] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:11.077]   - Field: 'node'
[17:29:11.078]   - Field: 'label'
[17:29:11.078]   - Field: 'local'
[17:29:11.078]   - Field: 'owner'
[17:29:11.078]   - Field: 'envir'
[17:29:11.079]   - Field: 'workers'
[17:29:11.079]   - Field: 'packages'
[17:29:11.079]   - Field: 'gc'
[17:29:11.080]   - Field: 'conditions'
[17:29:11.080]   - Field: 'persistent'
[17:29:11.080]   - Field: 'expr'
[17:29:11.081]   - Field: 'uuid'
[17:29:11.081]   - Field: 'seed'
[17:29:11.081]   - Field: 'version'
[17:29:11.081]   - Field: 'result'
[17:29:11.082]   - Field: 'asynchronous'
[17:29:11.082]   - Field: 'calls'
[17:29:11.082]   - Field: 'globals'
[17:29:11.083]   - Field: 'stdout'
[17:29:11.083]   - Field: 'earlySignal'
[17:29:11.083]   - Field: 'lazy'
[17:29:11.083]   - Field: 'state'
[17:29:11.084] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:11.084] - Launch lazy future ...
[17:29:11.085] Packages needed by the future expression (n = 0): <none>
[17:29:11.085] Packages needed by future strategies (n = 0): <none>
[17:29:11.086] {
[17:29:11.086]     {
[17:29:11.086]         {
[17:29:11.086]             ...future.startTime <- base::Sys.time()
[17:29:11.086]             {
[17:29:11.086]                 {
[17:29:11.086]                   {
[17:29:11.086]                     {
[17:29:11.086]                       base::local({
[17:29:11.086]                         has_future <- base::requireNamespace("future", 
[17:29:11.086]                           quietly = TRUE)
[17:29:11.086]                         if (has_future) {
[17:29:11.086]                           ns <- base::getNamespace("future")
[17:29:11.086]                           version <- ns[[".package"]][["version"]]
[17:29:11.086]                           if (is.null(version)) 
[17:29:11.086]                             version <- utils::packageVersion("future")
[17:29:11.086]                         }
[17:29:11.086]                         else {
[17:29:11.086]                           version <- NULL
[17:29:11.086]                         }
[17:29:11.086]                         if (!has_future || version < "1.8.0") {
[17:29:11.086]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:11.086]                             "", base::R.version$version.string), 
[17:29:11.086]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:11.086]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:11.086]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:11.086]                               "release", "version")], collapse = " "), 
[17:29:11.086]                             hostname = base::Sys.info()[["nodename"]])
[17:29:11.086]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:11.086]                             info)
[17:29:11.086]                           info <- base::paste(info, collapse = "; ")
[17:29:11.086]                           if (!has_future) {
[17:29:11.086]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:11.086]                               info)
[17:29:11.086]                           }
[17:29:11.086]                           else {
[17:29:11.086]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:11.086]                               info, version)
[17:29:11.086]                           }
[17:29:11.086]                           base::stop(msg)
[17:29:11.086]                         }
[17:29:11.086]                       })
[17:29:11.086]                     }
[17:29:11.086]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:11.086]                     base::options(mc.cores = 1L)
[17:29:11.086]                   }
[17:29:11.086]                   ...future.strategy.old <- future::plan("list")
[17:29:11.086]                   options(future.plan = NULL)
[17:29:11.086]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:11.086]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:11.086]                 }
[17:29:11.086]                 ...future.workdir <- getwd()
[17:29:11.086]             }
[17:29:11.086]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:11.086]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:11.086]         }
[17:29:11.086]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:11.086]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:11.086]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:11.086]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:11.086]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:11.086]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:11.086]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:11.086]             base::names(...future.oldOptions))
[17:29:11.086]     }
[17:29:11.086]     if (FALSE) {
[17:29:11.086]     }
[17:29:11.086]     else {
[17:29:11.086]         if (TRUE) {
[17:29:11.086]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:11.086]                 open = "w")
[17:29:11.086]         }
[17:29:11.086]         else {
[17:29:11.086]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:11.086]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:11.086]         }
[17:29:11.086]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:11.086]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:11.086]             base::sink(type = "output", split = FALSE)
[17:29:11.086]             base::close(...future.stdout)
[17:29:11.086]         }, add = TRUE)
[17:29:11.086]     }
[17:29:11.086]     ...future.frame <- base::sys.nframe()
[17:29:11.086]     ...future.conditions <- base::list()
[17:29:11.086]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:11.086]     if (FALSE) {
[17:29:11.086]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:11.086]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:11.086]     }
[17:29:11.086]     ...future.result <- base::tryCatch({
[17:29:11.086]         base::withCallingHandlers({
[17:29:11.086]             ...future.value <- base::withVisible(base::local({
[17:29:11.086]                 ...future.makeSendCondition <- base::local({
[17:29:11.086]                   sendCondition <- NULL
[17:29:11.086]                   function(frame = 1L) {
[17:29:11.086]                     if (is.function(sendCondition)) 
[17:29:11.086]                       return(sendCondition)
[17:29:11.086]                     ns <- getNamespace("parallel")
[17:29:11.086]                     if (exists("sendData", mode = "function", 
[17:29:11.086]                       envir = ns)) {
[17:29:11.086]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:11.086]                         envir = ns)
[17:29:11.086]                       envir <- sys.frame(frame)
[17:29:11.086]                       master <- NULL
[17:29:11.086]                       while (!identical(envir, .GlobalEnv) && 
[17:29:11.086]                         !identical(envir, emptyenv())) {
[17:29:11.086]                         if (exists("master", mode = "list", envir = envir, 
[17:29:11.086]                           inherits = FALSE)) {
[17:29:11.086]                           master <- get("master", mode = "list", 
[17:29:11.086]                             envir = envir, inherits = FALSE)
[17:29:11.086]                           if (inherits(master, c("SOCKnode", 
[17:29:11.086]                             "SOCK0node"))) {
[17:29:11.086]                             sendCondition <<- function(cond) {
[17:29:11.086]                               data <- list(type = "VALUE", value = cond, 
[17:29:11.086]                                 success = TRUE)
[17:29:11.086]                               parallel_sendData(master, data)
[17:29:11.086]                             }
[17:29:11.086]                             return(sendCondition)
[17:29:11.086]                           }
[17:29:11.086]                         }
[17:29:11.086]                         frame <- frame + 1L
[17:29:11.086]                         envir <- sys.frame(frame)
[17:29:11.086]                       }
[17:29:11.086]                     }
[17:29:11.086]                     sendCondition <<- function(cond) NULL
[17:29:11.086]                   }
[17:29:11.086]                 })
[17:29:11.086]                 withCallingHandlers({
[17:29:11.086]                   {
[17:29:11.086]                     Sys.sleep(0.5)
[17:29:11.086]                     list(a = 1, b = 42L)
[17:29:11.086]                   }
[17:29:11.086]                 }, immediateCondition = function(cond) {
[17:29:11.086]                   sendCondition <- ...future.makeSendCondition()
[17:29:11.086]                   sendCondition(cond)
[17:29:11.086]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:11.086]                   {
[17:29:11.086]                     inherits <- base::inherits
[17:29:11.086]                     invokeRestart <- base::invokeRestart
[17:29:11.086]                     is.null <- base::is.null
[17:29:11.086]                     muffled <- FALSE
[17:29:11.086]                     if (inherits(cond, "message")) {
[17:29:11.086]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:11.086]                       if (muffled) 
[17:29:11.086]                         invokeRestart("muffleMessage")
[17:29:11.086]                     }
[17:29:11.086]                     else if (inherits(cond, "warning")) {
[17:29:11.086]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:11.086]                       if (muffled) 
[17:29:11.086]                         invokeRestart("muffleWarning")
[17:29:11.086]                     }
[17:29:11.086]                     else if (inherits(cond, "condition")) {
[17:29:11.086]                       if (!is.null(pattern)) {
[17:29:11.086]                         computeRestarts <- base::computeRestarts
[17:29:11.086]                         grepl <- base::grepl
[17:29:11.086]                         restarts <- computeRestarts(cond)
[17:29:11.086]                         for (restart in restarts) {
[17:29:11.086]                           name <- restart$name
[17:29:11.086]                           if (is.null(name)) 
[17:29:11.086]                             next
[17:29:11.086]                           if (!grepl(pattern, name)) 
[17:29:11.086]                             next
[17:29:11.086]                           invokeRestart(restart)
[17:29:11.086]                           muffled <- TRUE
[17:29:11.086]                           break
[17:29:11.086]                         }
[17:29:11.086]                       }
[17:29:11.086]                     }
[17:29:11.086]                     invisible(muffled)
[17:29:11.086]                   }
[17:29:11.086]                   muffleCondition(cond)
[17:29:11.086]                 })
[17:29:11.086]             }))
[17:29:11.086]             future::FutureResult(value = ...future.value$value, 
[17:29:11.086]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:11.086]                   ...future.rng), globalenv = if (FALSE) 
[17:29:11.086]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:11.086]                     ...future.globalenv.names))
[17:29:11.086]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:11.086]         }, condition = base::local({
[17:29:11.086]             c <- base::c
[17:29:11.086]             inherits <- base::inherits
[17:29:11.086]             invokeRestart <- base::invokeRestart
[17:29:11.086]             length <- base::length
[17:29:11.086]             list <- base::list
[17:29:11.086]             seq.int <- base::seq.int
[17:29:11.086]             signalCondition <- base::signalCondition
[17:29:11.086]             sys.calls <- base::sys.calls
[17:29:11.086]             `[[` <- base::`[[`
[17:29:11.086]             `+` <- base::`+`
[17:29:11.086]             `<<-` <- base::`<<-`
[17:29:11.086]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:11.086]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:11.086]                   3L)]
[17:29:11.086]             }
[17:29:11.086]             function(cond) {
[17:29:11.086]                 is_error <- inherits(cond, "error")
[17:29:11.086]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:11.086]                   NULL)
[17:29:11.086]                 if (is_error) {
[17:29:11.086]                   sessionInformation <- function() {
[17:29:11.086]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:11.086]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:11.086]                       search = base::search(), system = base::Sys.info())
[17:29:11.086]                   }
[17:29:11.086]                   ...future.conditions[[length(...future.conditions) + 
[17:29:11.086]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:11.086]                     cond$call), session = sessionInformation(), 
[17:29:11.086]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:11.086]                   signalCondition(cond)
[17:29:11.086]                 }
[17:29:11.086]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:11.086]                 "immediateCondition"))) {
[17:29:11.086]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:11.086]                   ...future.conditions[[length(...future.conditions) + 
[17:29:11.086]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:11.086]                   if (TRUE && !signal) {
[17:29:11.086]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:11.086]                     {
[17:29:11.086]                       inherits <- base::inherits
[17:29:11.086]                       invokeRestart <- base::invokeRestart
[17:29:11.086]                       is.null <- base::is.null
[17:29:11.086]                       muffled <- FALSE
[17:29:11.086]                       if (inherits(cond, "message")) {
[17:29:11.086]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:11.086]                         if (muffled) 
[17:29:11.086]                           invokeRestart("muffleMessage")
[17:29:11.086]                       }
[17:29:11.086]                       else if (inherits(cond, "warning")) {
[17:29:11.086]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:11.086]                         if (muffled) 
[17:29:11.086]                           invokeRestart("muffleWarning")
[17:29:11.086]                       }
[17:29:11.086]                       else if (inherits(cond, "condition")) {
[17:29:11.086]                         if (!is.null(pattern)) {
[17:29:11.086]                           computeRestarts <- base::computeRestarts
[17:29:11.086]                           grepl <- base::grepl
[17:29:11.086]                           restarts <- computeRestarts(cond)
[17:29:11.086]                           for (restart in restarts) {
[17:29:11.086]                             name <- restart$name
[17:29:11.086]                             if (is.null(name)) 
[17:29:11.086]                               next
[17:29:11.086]                             if (!grepl(pattern, name)) 
[17:29:11.086]                               next
[17:29:11.086]                             invokeRestart(restart)
[17:29:11.086]                             muffled <- TRUE
[17:29:11.086]                             break
[17:29:11.086]                           }
[17:29:11.086]                         }
[17:29:11.086]                       }
[17:29:11.086]                       invisible(muffled)
[17:29:11.086]                     }
[17:29:11.086]                     muffleCondition(cond, pattern = "^muffle")
[17:29:11.086]                   }
[17:29:11.086]                 }
[17:29:11.086]                 else {
[17:29:11.086]                   if (TRUE) {
[17:29:11.086]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:11.086]                     {
[17:29:11.086]                       inherits <- base::inherits
[17:29:11.086]                       invokeRestart <- base::invokeRestart
[17:29:11.086]                       is.null <- base::is.null
[17:29:11.086]                       muffled <- FALSE
[17:29:11.086]                       if (inherits(cond, "message")) {
[17:29:11.086]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:11.086]                         if (muffled) 
[17:29:11.086]                           invokeRestart("muffleMessage")
[17:29:11.086]                       }
[17:29:11.086]                       else if (inherits(cond, "warning")) {
[17:29:11.086]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:11.086]                         if (muffled) 
[17:29:11.086]                           invokeRestart("muffleWarning")
[17:29:11.086]                       }
[17:29:11.086]                       else if (inherits(cond, "condition")) {
[17:29:11.086]                         if (!is.null(pattern)) {
[17:29:11.086]                           computeRestarts <- base::computeRestarts
[17:29:11.086]                           grepl <- base::grepl
[17:29:11.086]                           restarts <- computeRestarts(cond)
[17:29:11.086]                           for (restart in restarts) {
[17:29:11.086]                             name <- restart$name
[17:29:11.086]                             if (is.null(name)) 
[17:29:11.086]                               next
[17:29:11.086]                             if (!grepl(pattern, name)) 
[17:29:11.086]                               next
[17:29:11.086]                             invokeRestart(restart)
[17:29:11.086]                             muffled <- TRUE
[17:29:11.086]                             break
[17:29:11.086]                           }
[17:29:11.086]                         }
[17:29:11.086]                       }
[17:29:11.086]                       invisible(muffled)
[17:29:11.086]                     }
[17:29:11.086]                     muffleCondition(cond, pattern = "^muffle")
[17:29:11.086]                   }
[17:29:11.086]                 }
[17:29:11.086]             }
[17:29:11.086]         }))
[17:29:11.086]     }, error = function(ex) {
[17:29:11.086]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:11.086]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:11.086]                 ...future.rng), started = ...future.startTime, 
[17:29:11.086]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:11.086]             version = "1.8"), class = "FutureResult")
[17:29:11.086]     }, finally = {
[17:29:11.086]         if (!identical(...future.workdir, getwd())) 
[17:29:11.086]             setwd(...future.workdir)
[17:29:11.086]         {
[17:29:11.086]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:11.086]                 ...future.oldOptions$nwarnings <- NULL
[17:29:11.086]             }
[17:29:11.086]             base::options(...future.oldOptions)
[17:29:11.086]             if (.Platform$OS.type == "windows") {
[17:29:11.086]                 old_names <- names(...future.oldEnvVars)
[17:29:11.086]                 envs <- base::Sys.getenv()
[17:29:11.086]                 names <- names(envs)
[17:29:11.086]                 common <- intersect(names, old_names)
[17:29:11.086]                 added <- setdiff(names, old_names)
[17:29:11.086]                 removed <- setdiff(old_names, names)
[17:29:11.086]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:11.086]                   envs[common]]
[17:29:11.086]                 NAMES <- toupper(changed)
[17:29:11.086]                 args <- list()
[17:29:11.086]                 for (kk in seq_along(NAMES)) {
[17:29:11.086]                   name <- changed[[kk]]
[17:29:11.086]                   NAME <- NAMES[[kk]]
[17:29:11.086]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:11.086]                     next
[17:29:11.086]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:11.086]                 }
[17:29:11.086]                 NAMES <- toupper(added)
[17:29:11.086]                 for (kk in seq_along(NAMES)) {
[17:29:11.086]                   name <- added[[kk]]
[17:29:11.086]                   NAME <- NAMES[[kk]]
[17:29:11.086]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:11.086]                     next
[17:29:11.086]                   args[[name]] <- ""
[17:29:11.086]                 }
[17:29:11.086]                 NAMES <- toupper(removed)
[17:29:11.086]                 for (kk in seq_along(NAMES)) {
[17:29:11.086]                   name <- removed[[kk]]
[17:29:11.086]                   NAME <- NAMES[[kk]]
[17:29:11.086]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:11.086]                     next
[17:29:11.086]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:11.086]                 }
[17:29:11.086]                 if (length(args) > 0) 
[17:29:11.086]                   base::do.call(base::Sys.setenv, args = args)
[17:29:11.086]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:11.086]             }
[17:29:11.086]             else {
[17:29:11.086]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:11.086]             }
[17:29:11.086]             {
[17:29:11.086]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:11.086]                   0L) {
[17:29:11.086]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:11.086]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:11.086]                   base::options(opts)
[17:29:11.086]                 }
[17:29:11.086]                 {
[17:29:11.086]                   {
[17:29:11.086]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:11.086]                     NULL
[17:29:11.086]                   }
[17:29:11.086]                   options(future.plan = NULL)
[17:29:11.086]                   if (is.na(NA_character_)) 
[17:29:11.086]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:11.086]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:11.086]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:11.086]                     .init = FALSE)
[17:29:11.086]                 }
[17:29:11.086]             }
[17:29:11.086]         }
[17:29:11.086]     })
[17:29:11.086]     if (TRUE) {
[17:29:11.086]         base::sink(type = "output", split = FALSE)
[17:29:11.086]         if (TRUE) {
[17:29:11.086]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:11.086]         }
[17:29:11.086]         else {
[17:29:11.086]             ...future.result["stdout"] <- base::list(NULL)
[17:29:11.086]         }
[17:29:11.086]         base::close(...future.stdout)
[17:29:11.086]         ...future.stdout <- NULL
[17:29:11.086]     }
[17:29:11.086]     ...future.result$conditions <- ...future.conditions
[17:29:11.086]     ...future.result$finished <- base::Sys.time()
[17:29:11.086]     ...future.result
[17:29:11.086] }
[17:29:11.095] MultisessionFuture started
[17:29:11.096] - Launch lazy future ... done
[17:29:11.096] run() for 'MultisessionFuture' ... done
[17:29:11.643] receiveMessageFromWorker() for ClusterFuture ...
[17:29:11.643] - Validating connection of MultisessionFuture
[17:29:11.644] - received message: FutureResult
[17:29:11.644] - Received FutureResult
[17:29:11.644] - Erased future from FutureRegistry
[17:29:11.645] result() for ClusterFuture ...
[17:29:11.645] - result already collected: FutureResult
[17:29:11.645] result() for ClusterFuture ... done
[17:29:11.646] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:11.646] A MultisessionFuture was resolved (result was not collected)
- w/ exception ...
[17:29:11.646] getGlobalsAndPackages() ...
[17:29:11.646] Searching for globals...
[17:29:11.648] - globals found: [2] 'list', 'stop'
[17:29:11.648] Searching for globals ... DONE
[17:29:11.648] Resolving globals: FALSE
[17:29:11.649] 
[17:29:11.649] 
[17:29:11.650] getGlobalsAndPackages() ... DONE
[17:29:11.650] run() for 'Future' ...
[17:29:11.650] - state: 'created'
[17:29:11.651] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:11.671] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:11.671] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:11.671]   - Field: 'node'
[17:29:11.672]   - Field: 'label'
[17:29:11.672]   - Field: 'local'
[17:29:11.672]   - Field: 'owner'
[17:29:11.673]   - Field: 'envir'
[17:29:11.673]   - Field: 'workers'
[17:29:11.673]   - Field: 'packages'
[17:29:11.673]   - Field: 'gc'
[17:29:11.674]   - Field: 'conditions'
[17:29:11.674]   - Field: 'persistent'
[17:29:11.674]   - Field: 'expr'
[17:29:11.674]   - Field: 'uuid'
[17:29:11.675]   - Field: 'seed'
[17:29:11.675]   - Field: 'version'
[17:29:11.675]   - Field: 'result'
[17:29:11.675]   - Field: 'asynchronous'
[17:29:11.676]   - Field: 'calls'
[17:29:11.676]   - Field: 'globals'
[17:29:11.676]   - Field: 'stdout'
[17:29:11.676]   - Field: 'earlySignal'
[17:29:11.677]   - Field: 'lazy'
[17:29:11.677]   - Field: 'state'
[17:29:11.677] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:11.677] - Launch lazy future ...
[17:29:11.678] Packages needed by the future expression (n = 0): <none>
[17:29:11.678] Packages needed by future strategies (n = 0): <none>
[17:29:11.679] {
[17:29:11.679]     {
[17:29:11.679]         {
[17:29:11.679]             ...future.startTime <- base::Sys.time()
[17:29:11.679]             {
[17:29:11.679]                 {
[17:29:11.679]                   {
[17:29:11.679]                     {
[17:29:11.679]                       base::local({
[17:29:11.679]                         has_future <- base::requireNamespace("future", 
[17:29:11.679]                           quietly = TRUE)
[17:29:11.679]                         if (has_future) {
[17:29:11.679]                           ns <- base::getNamespace("future")
[17:29:11.679]                           version <- ns[[".package"]][["version"]]
[17:29:11.679]                           if (is.null(version)) 
[17:29:11.679]                             version <- utils::packageVersion("future")
[17:29:11.679]                         }
[17:29:11.679]                         else {
[17:29:11.679]                           version <- NULL
[17:29:11.679]                         }
[17:29:11.679]                         if (!has_future || version < "1.8.0") {
[17:29:11.679]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:11.679]                             "", base::R.version$version.string), 
[17:29:11.679]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:11.679]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:11.679]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:11.679]                               "release", "version")], collapse = " "), 
[17:29:11.679]                             hostname = base::Sys.info()[["nodename"]])
[17:29:11.679]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:11.679]                             info)
[17:29:11.679]                           info <- base::paste(info, collapse = "; ")
[17:29:11.679]                           if (!has_future) {
[17:29:11.679]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:11.679]                               info)
[17:29:11.679]                           }
[17:29:11.679]                           else {
[17:29:11.679]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:11.679]                               info, version)
[17:29:11.679]                           }
[17:29:11.679]                           base::stop(msg)
[17:29:11.679]                         }
[17:29:11.679]                       })
[17:29:11.679]                     }
[17:29:11.679]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:11.679]                     base::options(mc.cores = 1L)
[17:29:11.679]                   }
[17:29:11.679]                   ...future.strategy.old <- future::plan("list")
[17:29:11.679]                   options(future.plan = NULL)
[17:29:11.679]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:11.679]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:11.679]                 }
[17:29:11.679]                 ...future.workdir <- getwd()
[17:29:11.679]             }
[17:29:11.679]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:11.679]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:11.679]         }
[17:29:11.679]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:11.679]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:11.679]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:11.679]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:11.679]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:11.679]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:11.679]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:11.679]             base::names(...future.oldOptions))
[17:29:11.679]     }
[17:29:11.679]     if (FALSE) {
[17:29:11.679]     }
[17:29:11.679]     else {
[17:29:11.679]         if (TRUE) {
[17:29:11.679]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:11.679]                 open = "w")
[17:29:11.679]         }
[17:29:11.679]         else {
[17:29:11.679]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:11.679]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:11.679]         }
[17:29:11.679]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:11.679]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:11.679]             base::sink(type = "output", split = FALSE)
[17:29:11.679]             base::close(...future.stdout)
[17:29:11.679]         }, add = TRUE)
[17:29:11.679]     }
[17:29:11.679]     ...future.frame <- base::sys.nframe()
[17:29:11.679]     ...future.conditions <- base::list()
[17:29:11.679]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:11.679]     if (FALSE) {
[17:29:11.679]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:11.679]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:11.679]     }
[17:29:11.679]     ...future.result <- base::tryCatch({
[17:29:11.679]         base::withCallingHandlers({
[17:29:11.679]             ...future.value <- base::withVisible(base::local({
[17:29:11.679]                 ...future.makeSendCondition <- base::local({
[17:29:11.679]                   sendCondition <- NULL
[17:29:11.679]                   function(frame = 1L) {
[17:29:11.679]                     if (is.function(sendCondition)) 
[17:29:11.679]                       return(sendCondition)
[17:29:11.679]                     ns <- getNamespace("parallel")
[17:29:11.679]                     if (exists("sendData", mode = "function", 
[17:29:11.679]                       envir = ns)) {
[17:29:11.679]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:11.679]                         envir = ns)
[17:29:11.679]                       envir <- sys.frame(frame)
[17:29:11.679]                       master <- NULL
[17:29:11.679]                       while (!identical(envir, .GlobalEnv) && 
[17:29:11.679]                         !identical(envir, emptyenv())) {
[17:29:11.679]                         if (exists("master", mode = "list", envir = envir, 
[17:29:11.679]                           inherits = FALSE)) {
[17:29:11.679]                           master <- get("master", mode = "list", 
[17:29:11.679]                             envir = envir, inherits = FALSE)
[17:29:11.679]                           if (inherits(master, c("SOCKnode", 
[17:29:11.679]                             "SOCK0node"))) {
[17:29:11.679]                             sendCondition <<- function(cond) {
[17:29:11.679]                               data <- list(type = "VALUE", value = cond, 
[17:29:11.679]                                 success = TRUE)
[17:29:11.679]                               parallel_sendData(master, data)
[17:29:11.679]                             }
[17:29:11.679]                             return(sendCondition)
[17:29:11.679]                           }
[17:29:11.679]                         }
[17:29:11.679]                         frame <- frame + 1L
[17:29:11.679]                         envir <- sys.frame(frame)
[17:29:11.679]                       }
[17:29:11.679]                     }
[17:29:11.679]                     sendCondition <<- function(cond) NULL
[17:29:11.679]                   }
[17:29:11.679]                 })
[17:29:11.679]                 withCallingHandlers({
[17:29:11.679]                   list(a = 1, b = 42L, c = stop("Nah!"))
[17:29:11.679]                 }, immediateCondition = function(cond) {
[17:29:11.679]                   sendCondition <- ...future.makeSendCondition()
[17:29:11.679]                   sendCondition(cond)
[17:29:11.679]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:11.679]                   {
[17:29:11.679]                     inherits <- base::inherits
[17:29:11.679]                     invokeRestart <- base::invokeRestart
[17:29:11.679]                     is.null <- base::is.null
[17:29:11.679]                     muffled <- FALSE
[17:29:11.679]                     if (inherits(cond, "message")) {
[17:29:11.679]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:11.679]                       if (muffled) 
[17:29:11.679]                         invokeRestart("muffleMessage")
[17:29:11.679]                     }
[17:29:11.679]                     else if (inherits(cond, "warning")) {
[17:29:11.679]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:11.679]                       if (muffled) 
[17:29:11.679]                         invokeRestart("muffleWarning")
[17:29:11.679]                     }
[17:29:11.679]                     else if (inherits(cond, "condition")) {
[17:29:11.679]                       if (!is.null(pattern)) {
[17:29:11.679]                         computeRestarts <- base::computeRestarts
[17:29:11.679]                         grepl <- base::grepl
[17:29:11.679]                         restarts <- computeRestarts(cond)
[17:29:11.679]                         for (restart in restarts) {
[17:29:11.679]                           name <- restart$name
[17:29:11.679]                           if (is.null(name)) 
[17:29:11.679]                             next
[17:29:11.679]                           if (!grepl(pattern, name)) 
[17:29:11.679]                             next
[17:29:11.679]                           invokeRestart(restart)
[17:29:11.679]                           muffled <- TRUE
[17:29:11.679]                           break
[17:29:11.679]                         }
[17:29:11.679]                       }
[17:29:11.679]                     }
[17:29:11.679]                     invisible(muffled)
[17:29:11.679]                   }
[17:29:11.679]                   muffleCondition(cond)
[17:29:11.679]                 })
[17:29:11.679]             }))
[17:29:11.679]             future::FutureResult(value = ...future.value$value, 
[17:29:11.679]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:11.679]                   ...future.rng), globalenv = if (FALSE) 
[17:29:11.679]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:11.679]                     ...future.globalenv.names))
[17:29:11.679]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:11.679]         }, condition = base::local({
[17:29:11.679]             c <- base::c
[17:29:11.679]             inherits <- base::inherits
[17:29:11.679]             invokeRestart <- base::invokeRestart
[17:29:11.679]             length <- base::length
[17:29:11.679]             list <- base::list
[17:29:11.679]             seq.int <- base::seq.int
[17:29:11.679]             signalCondition <- base::signalCondition
[17:29:11.679]             sys.calls <- base::sys.calls
[17:29:11.679]             `[[` <- base::`[[`
[17:29:11.679]             `+` <- base::`+`
[17:29:11.679]             `<<-` <- base::`<<-`
[17:29:11.679]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:11.679]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:11.679]                   3L)]
[17:29:11.679]             }
[17:29:11.679]             function(cond) {
[17:29:11.679]                 is_error <- inherits(cond, "error")
[17:29:11.679]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:11.679]                   NULL)
[17:29:11.679]                 if (is_error) {
[17:29:11.679]                   sessionInformation <- function() {
[17:29:11.679]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:11.679]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:11.679]                       search = base::search(), system = base::Sys.info())
[17:29:11.679]                   }
[17:29:11.679]                   ...future.conditions[[length(...future.conditions) + 
[17:29:11.679]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:11.679]                     cond$call), session = sessionInformation(), 
[17:29:11.679]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:11.679]                   signalCondition(cond)
[17:29:11.679]                 }
[17:29:11.679]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:11.679]                 "immediateCondition"))) {
[17:29:11.679]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:11.679]                   ...future.conditions[[length(...future.conditions) + 
[17:29:11.679]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:11.679]                   if (TRUE && !signal) {
[17:29:11.679]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:11.679]                     {
[17:29:11.679]                       inherits <- base::inherits
[17:29:11.679]                       invokeRestart <- base::invokeRestart
[17:29:11.679]                       is.null <- base::is.null
[17:29:11.679]                       muffled <- FALSE
[17:29:11.679]                       if (inherits(cond, "message")) {
[17:29:11.679]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:11.679]                         if (muffled) 
[17:29:11.679]                           invokeRestart("muffleMessage")
[17:29:11.679]                       }
[17:29:11.679]                       else if (inherits(cond, "warning")) {
[17:29:11.679]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:11.679]                         if (muffled) 
[17:29:11.679]                           invokeRestart("muffleWarning")
[17:29:11.679]                       }
[17:29:11.679]                       else if (inherits(cond, "condition")) {
[17:29:11.679]                         if (!is.null(pattern)) {
[17:29:11.679]                           computeRestarts <- base::computeRestarts
[17:29:11.679]                           grepl <- base::grepl
[17:29:11.679]                           restarts <- computeRestarts(cond)
[17:29:11.679]                           for (restart in restarts) {
[17:29:11.679]                             name <- restart$name
[17:29:11.679]                             if (is.null(name)) 
[17:29:11.679]                               next
[17:29:11.679]                             if (!grepl(pattern, name)) 
[17:29:11.679]                               next
[17:29:11.679]                             invokeRestart(restart)
[17:29:11.679]                             muffled <- TRUE
[17:29:11.679]                             break
[17:29:11.679]                           }
[17:29:11.679]                         }
[17:29:11.679]                       }
[17:29:11.679]                       invisible(muffled)
[17:29:11.679]                     }
[17:29:11.679]                     muffleCondition(cond, pattern = "^muffle")
[17:29:11.679]                   }
[17:29:11.679]                 }
[17:29:11.679]                 else {
[17:29:11.679]                   if (TRUE) {
[17:29:11.679]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:11.679]                     {
[17:29:11.679]                       inherits <- base::inherits
[17:29:11.679]                       invokeRestart <- base::invokeRestart
[17:29:11.679]                       is.null <- base::is.null
[17:29:11.679]                       muffled <- FALSE
[17:29:11.679]                       if (inherits(cond, "message")) {
[17:29:11.679]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:11.679]                         if (muffled) 
[17:29:11.679]                           invokeRestart("muffleMessage")
[17:29:11.679]                       }
[17:29:11.679]                       else if (inherits(cond, "warning")) {
[17:29:11.679]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:11.679]                         if (muffled) 
[17:29:11.679]                           invokeRestart("muffleWarning")
[17:29:11.679]                       }
[17:29:11.679]                       else if (inherits(cond, "condition")) {
[17:29:11.679]                         if (!is.null(pattern)) {
[17:29:11.679]                           computeRestarts <- base::computeRestarts
[17:29:11.679]                           grepl <- base::grepl
[17:29:11.679]                           restarts <- computeRestarts(cond)
[17:29:11.679]                           for (restart in restarts) {
[17:29:11.679]                             name <- restart$name
[17:29:11.679]                             if (is.null(name)) 
[17:29:11.679]                               next
[17:29:11.679]                             if (!grepl(pattern, name)) 
[17:29:11.679]                               next
[17:29:11.679]                             invokeRestart(restart)
[17:29:11.679]                             muffled <- TRUE
[17:29:11.679]                             break
[17:29:11.679]                           }
[17:29:11.679]                         }
[17:29:11.679]                       }
[17:29:11.679]                       invisible(muffled)
[17:29:11.679]                     }
[17:29:11.679]                     muffleCondition(cond, pattern = "^muffle")
[17:29:11.679]                   }
[17:29:11.679]                 }
[17:29:11.679]             }
[17:29:11.679]         }))
[17:29:11.679]     }, error = function(ex) {
[17:29:11.679]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:11.679]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:11.679]                 ...future.rng), started = ...future.startTime, 
[17:29:11.679]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:11.679]             version = "1.8"), class = "FutureResult")
[17:29:11.679]     }, finally = {
[17:29:11.679]         if (!identical(...future.workdir, getwd())) 
[17:29:11.679]             setwd(...future.workdir)
[17:29:11.679]         {
[17:29:11.679]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:11.679]                 ...future.oldOptions$nwarnings <- NULL
[17:29:11.679]             }
[17:29:11.679]             base::options(...future.oldOptions)
[17:29:11.679]             if (.Platform$OS.type == "windows") {
[17:29:11.679]                 old_names <- names(...future.oldEnvVars)
[17:29:11.679]                 envs <- base::Sys.getenv()
[17:29:11.679]                 names <- names(envs)
[17:29:11.679]                 common <- intersect(names, old_names)
[17:29:11.679]                 added <- setdiff(names, old_names)
[17:29:11.679]                 removed <- setdiff(old_names, names)
[17:29:11.679]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:11.679]                   envs[common]]
[17:29:11.679]                 NAMES <- toupper(changed)
[17:29:11.679]                 args <- list()
[17:29:11.679]                 for (kk in seq_along(NAMES)) {
[17:29:11.679]                   name <- changed[[kk]]
[17:29:11.679]                   NAME <- NAMES[[kk]]
[17:29:11.679]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:11.679]                     next
[17:29:11.679]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:11.679]                 }
[17:29:11.679]                 NAMES <- toupper(added)
[17:29:11.679]                 for (kk in seq_along(NAMES)) {
[17:29:11.679]                   name <- added[[kk]]
[17:29:11.679]                   NAME <- NAMES[[kk]]
[17:29:11.679]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:11.679]                     next
[17:29:11.679]                   args[[name]] <- ""
[17:29:11.679]                 }
[17:29:11.679]                 NAMES <- toupper(removed)
[17:29:11.679]                 for (kk in seq_along(NAMES)) {
[17:29:11.679]                   name <- removed[[kk]]
[17:29:11.679]                   NAME <- NAMES[[kk]]
[17:29:11.679]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:11.679]                     next
[17:29:11.679]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:11.679]                 }
[17:29:11.679]                 if (length(args) > 0) 
[17:29:11.679]                   base::do.call(base::Sys.setenv, args = args)
[17:29:11.679]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:11.679]             }
[17:29:11.679]             else {
[17:29:11.679]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:11.679]             }
[17:29:11.679]             {
[17:29:11.679]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:11.679]                   0L) {
[17:29:11.679]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:11.679]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:11.679]                   base::options(opts)
[17:29:11.679]                 }
[17:29:11.679]                 {
[17:29:11.679]                   {
[17:29:11.679]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:11.679]                     NULL
[17:29:11.679]                   }
[17:29:11.679]                   options(future.plan = NULL)
[17:29:11.679]                   if (is.na(NA_character_)) 
[17:29:11.679]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:11.679]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:11.679]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:11.679]                     .init = FALSE)
[17:29:11.679]                 }
[17:29:11.679]             }
[17:29:11.679]         }
[17:29:11.679]     })
[17:29:11.679]     if (TRUE) {
[17:29:11.679]         base::sink(type = "output", split = FALSE)
[17:29:11.679]         if (TRUE) {
[17:29:11.679]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:11.679]         }
[17:29:11.679]         else {
[17:29:11.679]             ...future.result["stdout"] <- base::list(NULL)
[17:29:11.679]         }
[17:29:11.679]         base::close(...future.stdout)
[17:29:11.679]         ...future.stdout <- NULL
[17:29:11.679]     }
[17:29:11.679]     ...future.result$conditions <- ...future.conditions
[17:29:11.679]     ...future.result$finished <- base::Sys.time()
[17:29:11.679]     ...future.result
[17:29:11.679] }
[17:29:11.689] MultisessionFuture started
[17:29:11.689] - Launch lazy future ... done
[17:29:11.690] run() for 'MultisessionFuture' ... done
[17:29:11.720] receiveMessageFromWorker() for ClusterFuture ...
[17:29:11.721] - Validating connection of MultisessionFuture
[17:29:11.721] - received message: FutureResult
[17:29:11.722] - Received FutureResult
[17:29:11.722] - Erased future from FutureRegistry
[17:29:11.722] result() for ClusterFuture ...
[17:29:11.723] - result already collected: FutureResult
[17:29:11.723] result() for ClusterFuture ... done
[17:29:11.723] signalConditions() ...
[17:29:11.723]  - include = 'immediateCondition'
[17:29:11.724]  - exclude = 
[17:29:11.724]  - resignal = FALSE
[17:29:11.724]  - Number of conditions: 1
[17:29:11.724] signalConditions() ... done
[17:29:11.725] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:11.725] A MultisessionFuture was resolved (result was not collected)
[17:29:11.725] getGlobalsAndPackages() ...
[17:29:11.725] Searching for globals...
[17:29:11.727] - globals found: [2] 'list', 'stop'
[17:29:11.727] Searching for globals ... DONE
[17:29:11.727] Resolving globals: FALSE
[17:29:11.728] 
[17:29:11.728] 
[17:29:11.728] getGlobalsAndPackages() ... DONE
[17:29:11.729] run() for 'Future' ...
[17:29:11.729] - state: 'created'
[17:29:11.730] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:11.748] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:11.748] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:11.749]   - Field: 'node'
[17:29:11.749]   - Field: 'label'
[17:29:11.749]   - Field: 'local'
[17:29:11.749]   - Field: 'owner'
[17:29:11.749]   - Field: 'envir'
[17:29:11.750]   - Field: 'workers'
[17:29:11.750]   - Field: 'packages'
[17:29:11.750]   - Field: 'gc'
[17:29:11.750]   - Field: 'conditions'
[17:29:11.750]   - Field: 'persistent'
[17:29:11.751]   - Field: 'expr'
[17:29:11.751]   - Field: 'uuid'
[17:29:11.751]   - Field: 'seed'
[17:29:11.751]   - Field: 'version'
[17:29:11.751]   - Field: 'result'
[17:29:11.751]   - Field: 'asynchronous'
[17:29:11.752]   - Field: 'calls'
[17:29:11.752]   - Field: 'globals'
[17:29:11.752]   - Field: 'stdout'
[17:29:11.752]   - Field: 'earlySignal'
[17:29:11.752]   - Field: 'lazy'
[17:29:11.752]   - Field: 'state'
[17:29:11.753] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:11.753] - Launch lazy future ...
[17:29:11.753] Packages needed by the future expression (n = 0): <none>
[17:29:11.754] Packages needed by future strategies (n = 0): <none>
[17:29:11.754] {
[17:29:11.754]     {
[17:29:11.754]         {
[17:29:11.754]             ...future.startTime <- base::Sys.time()
[17:29:11.754]             {
[17:29:11.754]                 {
[17:29:11.754]                   {
[17:29:11.754]                     {
[17:29:11.754]                       base::local({
[17:29:11.754]                         has_future <- base::requireNamespace("future", 
[17:29:11.754]                           quietly = TRUE)
[17:29:11.754]                         if (has_future) {
[17:29:11.754]                           ns <- base::getNamespace("future")
[17:29:11.754]                           version <- ns[[".package"]][["version"]]
[17:29:11.754]                           if (is.null(version)) 
[17:29:11.754]                             version <- utils::packageVersion("future")
[17:29:11.754]                         }
[17:29:11.754]                         else {
[17:29:11.754]                           version <- NULL
[17:29:11.754]                         }
[17:29:11.754]                         if (!has_future || version < "1.8.0") {
[17:29:11.754]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:11.754]                             "", base::R.version$version.string), 
[17:29:11.754]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:11.754]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:11.754]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:11.754]                               "release", "version")], collapse = " "), 
[17:29:11.754]                             hostname = base::Sys.info()[["nodename"]])
[17:29:11.754]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:11.754]                             info)
[17:29:11.754]                           info <- base::paste(info, collapse = "; ")
[17:29:11.754]                           if (!has_future) {
[17:29:11.754]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:11.754]                               info)
[17:29:11.754]                           }
[17:29:11.754]                           else {
[17:29:11.754]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:11.754]                               info, version)
[17:29:11.754]                           }
[17:29:11.754]                           base::stop(msg)
[17:29:11.754]                         }
[17:29:11.754]                       })
[17:29:11.754]                     }
[17:29:11.754]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:11.754]                     base::options(mc.cores = 1L)
[17:29:11.754]                   }
[17:29:11.754]                   ...future.strategy.old <- future::plan("list")
[17:29:11.754]                   options(future.plan = NULL)
[17:29:11.754]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:11.754]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:11.754]                 }
[17:29:11.754]                 ...future.workdir <- getwd()
[17:29:11.754]             }
[17:29:11.754]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:11.754]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:11.754]         }
[17:29:11.754]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:11.754]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:11.754]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:11.754]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:11.754]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:11.754]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:11.754]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:11.754]             base::names(...future.oldOptions))
[17:29:11.754]     }
[17:29:11.754]     if (FALSE) {
[17:29:11.754]     }
[17:29:11.754]     else {
[17:29:11.754]         if (TRUE) {
[17:29:11.754]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:11.754]                 open = "w")
[17:29:11.754]         }
[17:29:11.754]         else {
[17:29:11.754]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:11.754]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:11.754]         }
[17:29:11.754]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:11.754]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:11.754]             base::sink(type = "output", split = FALSE)
[17:29:11.754]             base::close(...future.stdout)
[17:29:11.754]         }, add = TRUE)
[17:29:11.754]     }
[17:29:11.754]     ...future.frame <- base::sys.nframe()
[17:29:11.754]     ...future.conditions <- base::list()
[17:29:11.754]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:11.754]     if (FALSE) {
[17:29:11.754]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:11.754]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:11.754]     }
[17:29:11.754]     ...future.result <- base::tryCatch({
[17:29:11.754]         base::withCallingHandlers({
[17:29:11.754]             ...future.value <- base::withVisible(base::local({
[17:29:11.754]                 ...future.makeSendCondition <- base::local({
[17:29:11.754]                   sendCondition <- NULL
[17:29:11.754]                   function(frame = 1L) {
[17:29:11.754]                     if (is.function(sendCondition)) 
[17:29:11.754]                       return(sendCondition)
[17:29:11.754]                     ns <- getNamespace("parallel")
[17:29:11.754]                     if (exists("sendData", mode = "function", 
[17:29:11.754]                       envir = ns)) {
[17:29:11.754]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:11.754]                         envir = ns)
[17:29:11.754]                       envir <- sys.frame(frame)
[17:29:11.754]                       master <- NULL
[17:29:11.754]                       while (!identical(envir, .GlobalEnv) && 
[17:29:11.754]                         !identical(envir, emptyenv())) {
[17:29:11.754]                         if (exists("master", mode = "list", envir = envir, 
[17:29:11.754]                           inherits = FALSE)) {
[17:29:11.754]                           master <- get("master", mode = "list", 
[17:29:11.754]                             envir = envir, inherits = FALSE)
[17:29:11.754]                           if (inherits(master, c("SOCKnode", 
[17:29:11.754]                             "SOCK0node"))) {
[17:29:11.754]                             sendCondition <<- function(cond) {
[17:29:11.754]                               data <- list(type = "VALUE", value = cond, 
[17:29:11.754]                                 success = TRUE)
[17:29:11.754]                               parallel_sendData(master, data)
[17:29:11.754]                             }
[17:29:11.754]                             return(sendCondition)
[17:29:11.754]                           }
[17:29:11.754]                         }
[17:29:11.754]                         frame <- frame + 1L
[17:29:11.754]                         envir <- sys.frame(frame)
[17:29:11.754]                       }
[17:29:11.754]                     }
[17:29:11.754]                     sendCondition <<- function(cond) NULL
[17:29:11.754]                   }
[17:29:11.754]                 })
[17:29:11.754]                 withCallingHandlers({
[17:29:11.754]                   list(a = 1, b = 42L, c = stop("Nah!"))
[17:29:11.754]                 }, immediateCondition = function(cond) {
[17:29:11.754]                   sendCondition <- ...future.makeSendCondition()
[17:29:11.754]                   sendCondition(cond)
[17:29:11.754]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:11.754]                   {
[17:29:11.754]                     inherits <- base::inherits
[17:29:11.754]                     invokeRestart <- base::invokeRestart
[17:29:11.754]                     is.null <- base::is.null
[17:29:11.754]                     muffled <- FALSE
[17:29:11.754]                     if (inherits(cond, "message")) {
[17:29:11.754]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:11.754]                       if (muffled) 
[17:29:11.754]                         invokeRestart("muffleMessage")
[17:29:11.754]                     }
[17:29:11.754]                     else if (inherits(cond, "warning")) {
[17:29:11.754]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:11.754]                       if (muffled) 
[17:29:11.754]                         invokeRestart("muffleWarning")
[17:29:11.754]                     }
[17:29:11.754]                     else if (inherits(cond, "condition")) {
[17:29:11.754]                       if (!is.null(pattern)) {
[17:29:11.754]                         computeRestarts <- base::computeRestarts
[17:29:11.754]                         grepl <- base::grepl
[17:29:11.754]                         restarts <- computeRestarts(cond)
[17:29:11.754]                         for (restart in restarts) {
[17:29:11.754]                           name <- restart$name
[17:29:11.754]                           if (is.null(name)) 
[17:29:11.754]                             next
[17:29:11.754]                           if (!grepl(pattern, name)) 
[17:29:11.754]                             next
[17:29:11.754]                           invokeRestart(restart)
[17:29:11.754]                           muffled <- TRUE
[17:29:11.754]                           break
[17:29:11.754]                         }
[17:29:11.754]                       }
[17:29:11.754]                     }
[17:29:11.754]                     invisible(muffled)
[17:29:11.754]                   }
[17:29:11.754]                   muffleCondition(cond)
[17:29:11.754]                 })
[17:29:11.754]             }))
[17:29:11.754]             future::FutureResult(value = ...future.value$value, 
[17:29:11.754]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:11.754]                   ...future.rng), globalenv = if (FALSE) 
[17:29:11.754]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:11.754]                     ...future.globalenv.names))
[17:29:11.754]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:11.754]         }, condition = base::local({
[17:29:11.754]             c <- base::c
[17:29:11.754]             inherits <- base::inherits
[17:29:11.754]             invokeRestart <- base::invokeRestart
[17:29:11.754]             length <- base::length
[17:29:11.754]             list <- base::list
[17:29:11.754]             seq.int <- base::seq.int
[17:29:11.754]             signalCondition <- base::signalCondition
[17:29:11.754]             sys.calls <- base::sys.calls
[17:29:11.754]             `[[` <- base::`[[`
[17:29:11.754]             `+` <- base::`+`
[17:29:11.754]             `<<-` <- base::`<<-`
[17:29:11.754]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:11.754]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:11.754]                   3L)]
[17:29:11.754]             }
[17:29:11.754]             function(cond) {
[17:29:11.754]                 is_error <- inherits(cond, "error")
[17:29:11.754]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:11.754]                   NULL)
[17:29:11.754]                 if (is_error) {
[17:29:11.754]                   sessionInformation <- function() {
[17:29:11.754]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:11.754]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:11.754]                       search = base::search(), system = base::Sys.info())
[17:29:11.754]                   }
[17:29:11.754]                   ...future.conditions[[length(...future.conditions) + 
[17:29:11.754]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:11.754]                     cond$call), session = sessionInformation(), 
[17:29:11.754]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:11.754]                   signalCondition(cond)
[17:29:11.754]                 }
[17:29:11.754]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:11.754]                 "immediateCondition"))) {
[17:29:11.754]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:11.754]                   ...future.conditions[[length(...future.conditions) + 
[17:29:11.754]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:11.754]                   if (TRUE && !signal) {
[17:29:11.754]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:11.754]                     {
[17:29:11.754]                       inherits <- base::inherits
[17:29:11.754]                       invokeRestart <- base::invokeRestart
[17:29:11.754]                       is.null <- base::is.null
[17:29:11.754]                       muffled <- FALSE
[17:29:11.754]                       if (inherits(cond, "message")) {
[17:29:11.754]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:11.754]                         if (muffled) 
[17:29:11.754]                           invokeRestart("muffleMessage")
[17:29:11.754]                       }
[17:29:11.754]                       else if (inherits(cond, "warning")) {
[17:29:11.754]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:11.754]                         if (muffled) 
[17:29:11.754]                           invokeRestart("muffleWarning")
[17:29:11.754]                       }
[17:29:11.754]                       else if (inherits(cond, "condition")) {
[17:29:11.754]                         if (!is.null(pattern)) {
[17:29:11.754]                           computeRestarts <- base::computeRestarts
[17:29:11.754]                           grepl <- base::grepl
[17:29:11.754]                           restarts <- computeRestarts(cond)
[17:29:11.754]                           for (restart in restarts) {
[17:29:11.754]                             name <- restart$name
[17:29:11.754]                             if (is.null(name)) 
[17:29:11.754]                               next
[17:29:11.754]                             if (!grepl(pattern, name)) 
[17:29:11.754]                               next
[17:29:11.754]                             invokeRestart(restart)
[17:29:11.754]                             muffled <- TRUE
[17:29:11.754]                             break
[17:29:11.754]                           }
[17:29:11.754]                         }
[17:29:11.754]                       }
[17:29:11.754]                       invisible(muffled)
[17:29:11.754]                     }
[17:29:11.754]                     muffleCondition(cond, pattern = "^muffle")
[17:29:11.754]                   }
[17:29:11.754]                 }
[17:29:11.754]                 else {
[17:29:11.754]                   if (TRUE) {
[17:29:11.754]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:11.754]                     {
[17:29:11.754]                       inherits <- base::inherits
[17:29:11.754]                       invokeRestart <- base::invokeRestart
[17:29:11.754]                       is.null <- base::is.null
[17:29:11.754]                       muffled <- FALSE
[17:29:11.754]                       if (inherits(cond, "message")) {
[17:29:11.754]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:11.754]                         if (muffled) 
[17:29:11.754]                           invokeRestart("muffleMessage")
[17:29:11.754]                       }
[17:29:11.754]                       else if (inherits(cond, "warning")) {
[17:29:11.754]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:11.754]                         if (muffled) 
[17:29:11.754]                           invokeRestart("muffleWarning")
[17:29:11.754]                       }
[17:29:11.754]                       else if (inherits(cond, "condition")) {
[17:29:11.754]                         if (!is.null(pattern)) {
[17:29:11.754]                           computeRestarts <- base::computeRestarts
[17:29:11.754]                           grepl <- base::grepl
[17:29:11.754]                           restarts <- computeRestarts(cond)
[17:29:11.754]                           for (restart in restarts) {
[17:29:11.754]                             name <- restart$name
[17:29:11.754]                             if (is.null(name)) 
[17:29:11.754]                               next
[17:29:11.754]                             if (!grepl(pattern, name)) 
[17:29:11.754]                               next
[17:29:11.754]                             invokeRestart(restart)
[17:29:11.754]                             muffled <- TRUE
[17:29:11.754]                             break
[17:29:11.754]                           }
[17:29:11.754]                         }
[17:29:11.754]                       }
[17:29:11.754]                       invisible(muffled)
[17:29:11.754]                     }
[17:29:11.754]                     muffleCondition(cond, pattern = "^muffle")
[17:29:11.754]                   }
[17:29:11.754]                 }
[17:29:11.754]             }
[17:29:11.754]         }))
[17:29:11.754]     }, error = function(ex) {
[17:29:11.754]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:11.754]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:11.754]                 ...future.rng), started = ...future.startTime, 
[17:29:11.754]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:11.754]             version = "1.8"), class = "FutureResult")
[17:29:11.754]     }, finally = {
[17:29:11.754]         if (!identical(...future.workdir, getwd())) 
[17:29:11.754]             setwd(...future.workdir)
[17:29:11.754]         {
[17:29:11.754]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:11.754]                 ...future.oldOptions$nwarnings <- NULL
[17:29:11.754]             }
[17:29:11.754]             base::options(...future.oldOptions)
[17:29:11.754]             if (.Platform$OS.type == "windows") {
[17:29:11.754]                 old_names <- names(...future.oldEnvVars)
[17:29:11.754]                 envs <- base::Sys.getenv()
[17:29:11.754]                 names <- names(envs)
[17:29:11.754]                 common <- intersect(names, old_names)
[17:29:11.754]                 added <- setdiff(names, old_names)
[17:29:11.754]                 removed <- setdiff(old_names, names)
[17:29:11.754]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:11.754]                   envs[common]]
[17:29:11.754]                 NAMES <- toupper(changed)
[17:29:11.754]                 args <- list()
[17:29:11.754]                 for (kk in seq_along(NAMES)) {
[17:29:11.754]                   name <- changed[[kk]]
[17:29:11.754]                   NAME <- NAMES[[kk]]
[17:29:11.754]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:11.754]                     next
[17:29:11.754]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:11.754]                 }
[17:29:11.754]                 NAMES <- toupper(added)
[17:29:11.754]                 for (kk in seq_along(NAMES)) {
[17:29:11.754]                   name <- added[[kk]]
[17:29:11.754]                   NAME <- NAMES[[kk]]
[17:29:11.754]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:11.754]                     next
[17:29:11.754]                   args[[name]] <- ""
[17:29:11.754]                 }
[17:29:11.754]                 NAMES <- toupper(removed)
[17:29:11.754]                 for (kk in seq_along(NAMES)) {
[17:29:11.754]                   name <- removed[[kk]]
[17:29:11.754]                   NAME <- NAMES[[kk]]
[17:29:11.754]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:11.754]                     next
[17:29:11.754]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:11.754]                 }
[17:29:11.754]                 if (length(args) > 0) 
[17:29:11.754]                   base::do.call(base::Sys.setenv, args = args)
[17:29:11.754]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:11.754]             }
[17:29:11.754]             else {
[17:29:11.754]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:11.754]             }
[17:29:11.754]             {
[17:29:11.754]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:11.754]                   0L) {
[17:29:11.754]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:11.754]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:11.754]                   base::options(opts)
[17:29:11.754]                 }
[17:29:11.754]                 {
[17:29:11.754]                   {
[17:29:11.754]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:11.754]                     NULL
[17:29:11.754]                   }
[17:29:11.754]                   options(future.plan = NULL)
[17:29:11.754]                   if (is.na(NA_character_)) 
[17:29:11.754]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:11.754]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:11.754]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:11.754]                     .init = FALSE)
[17:29:11.754]                 }
[17:29:11.754]             }
[17:29:11.754]         }
[17:29:11.754]     })
[17:29:11.754]     if (TRUE) {
[17:29:11.754]         base::sink(type = "output", split = FALSE)
[17:29:11.754]         if (TRUE) {
[17:29:11.754]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:11.754]         }
[17:29:11.754]         else {
[17:29:11.754]             ...future.result["stdout"] <- base::list(NULL)
[17:29:11.754]         }
[17:29:11.754]         base::close(...future.stdout)
[17:29:11.754]         ...future.stdout <- NULL
[17:29:11.754]     }
[17:29:11.754]     ...future.result$conditions <- ...future.conditions
[17:29:11.754]     ...future.result$finished <- base::Sys.time()
[17:29:11.754]     ...future.result
[17:29:11.754] }
[17:29:11.761] MultisessionFuture started
[17:29:11.761] - Launch lazy future ... done
[17:29:11.762] run() for 'MultisessionFuture' ... done
[17:29:11.781] receiveMessageFromWorker() for ClusterFuture ...
[17:29:11.782] - Validating connection of MultisessionFuture
[17:29:11.783] - received message: FutureResult
[17:29:11.783] - Received FutureResult
[17:29:11.783] - Erased future from FutureRegistry
[17:29:11.784] result() for ClusterFuture ...
[17:29:11.784] - result already collected: FutureResult
[17:29:11.784] result() for ClusterFuture ... done
[17:29:11.785] signalConditions() ...
[17:29:11.785]  - include = 'immediateCondition'
[17:29:11.785]  - exclude = 
[17:29:11.785]  - resignal = FALSE
[17:29:11.786]  - Number of conditions: 1
[17:29:11.786] signalConditions() ... done
[17:29:11.786] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:11.787] A MultisessionFuture was resolved (result was not collected)
- result = FALSE, recursive = 0 ... DONE
- result = FALSE, recursive = 1 ...
[17:29:11.787] getGlobalsAndPackages() ...
[17:29:11.788] Searching for globals...
[17:29:11.790] - globals found: [3] '{', 'Sys.sleep', 'list'
[17:29:11.790] Searching for globals ... DONE
[17:29:11.791] Resolving globals: FALSE
[17:29:11.791] 
[17:29:11.792] 
[17:29:11.792] getGlobalsAndPackages() ... DONE
[17:29:11.792] run() for 'Future' ...
[17:29:11.793] - state: 'created'
[17:29:11.793] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:11.814] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:11.814] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:11.815]   - Field: 'node'
[17:29:11.815]   - Field: 'label'
[17:29:11.815]   - Field: 'local'
[17:29:11.816]   - Field: 'owner'
[17:29:11.816]   - Field: 'envir'
[17:29:11.816]   - Field: 'workers'
[17:29:11.816]   - Field: 'packages'
[17:29:11.817]   - Field: 'gc'
[17:29:11.817]   - Field: 'conditions'
[17:29:11.817]   - Field: 'persistent'
[17:29:11.818]   - Field: 'expr'
[17:29:11.818]   - Field: 'uuid'
[17:29:11.818]   - Field: 'seed'
[17:29:11.819]   - Field: 'version'
[17:29:11.819]   - Field: 'result'
[17:29:11.819]   - Field: 'asynchronous'
[17:29:11.820]   - Field: 'calls'
[17:29:11.820]   - Field: 'globals'
[17:29:11.820]   - Field: 'stdout'
[17:29:11.820]   - Field: 'earlySignal'
[17:29:11.821]   - Field: 'lazy'
[17:29:11.821]   - Field: 'state'
[17:29:11.821] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:11.822] - Launch lazy future ...
[17:29:11.822] Packages needed by the future expression (n = 0): <none>
[17:29:11.823] Packages needed by future strategies (n = 0): <none>
[17:29:11.824] {
[17:29:11.824]     {
[17:29:11.824]         {
[17:29:11.824]             ...future.startTime <- base::Sys.time()
[17:29:11.824]             {
[17:29:11.824]                 {
[17:29:11.824]                   {
[17:29:11.824]                     {
[17:29:11.824]                       base::local({
[17:29:11.824]                         has_future <- base::requireNamespace("future", 
[17:29:11.824]                           quietly = TRUE)
[17:29:11.824]                         if (has_future) {
[17:29:11.824]                           ns <- base::getNamespace("future")
[17:29:11.824]                           version <- ns[[".package"]][["version"]]
[17:29:11.824]                           if (is.null(version)) 
[17:29:11.824]                             version <- utils::packageVersion("future")
[17:29:11.824]                         }
[17:29:11.824]                         else {
[17:29:11.824]                           version <- NULL
[17:29:11.824]                         }
[17:29:11.824]                         if (!has_future || version < "1.8.0") {
[17:29:11.824]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:11.824]                             "", base::R.version$version.string), 
[17:29:11.824]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:11.824]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:11.824]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:11.824]                               "release", "version")], collapse = " "), 
[17:29:11.824]                             hostname = base::Sys.info()[["nodename"]])
[17:29:11.824]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:11.824]                             info)
[17:29:11.824]                           info <- base::paste(info, collapse = "; ")
[17:29:11.824]                           if (!has_future) {
[17:29:11.824]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:11.824]                               info)
[17:29:11.824]                           }
[17:29:11.824]                           else {
[17:29:11.824]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:11.824]                               info, version)
[17:29:11.824]                           }
[17:29:11.824]                           base::stop(msg)
[17:29:11.824]                         }
[17:29:11.824]                       })
[17:29:11.824]                     }
[17:29:11.824]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:11.824]                     base::options(mc.cores = 1L)
[17:29:11.824]                   }
[17:29:11.824]                   ...future.strategy.old <- future::plan("list")
[17:29:11.824]                   options(future.plan = NULL)
[17:29:11.824]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:11.824]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:11.824]                 }
[17:29:11.824]                 ...future.workdir <- getwd()
[17:29:11.824]             }
[17:29:11.824]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:11.824]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:11.824]         }
[17:29:11.824]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:11.824]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:11.824]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:11.824]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:11.824]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:11.824]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:11.824]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:11.824]             base::names(...future.oldOptions))
[17:29:11.824]     }
[17:29:11.824]     if (FALSE) {
[17:29:11.824]     }
[17:29:11.824]     else {
[17:29:11.824]         if (TRUE) {
[17:29:11.824]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:11.824]                 open = "w")
[17:29:11.824]         }
[17:29:11.824]         else {
[17:29:11.824]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:11.824]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:11.824]         }
[17:29:11.824]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:11.824]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:11.824]             base::sink(type = "output", split = FALSE)
[17:29:11.824]             base::close(...future.stdout)
[17:29:11.824]         }, add = TRUE)
[17:29:11.824]     }
[17:29:11.824]     ...future.frame <- base::sys.nframe()
[17:29:11.824]     ...future.conditions <- base::list()
[17:29:11.824]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:11.824]     if (FALSE) {
[17:29:11.824]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:11.824]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:11.824]     }
[17:29:11.824]     ...future.result <- base::tryCatch({
[17:29:11.824]         base::withCallingHandlers({
[17:29:11.824]             ...future.value <- base::withVisible(base::local({
[17:29:11.824]                 ...future.makeSendCondition <- base::local({
[17:29:11.824]                   sendCondition <- NULL
[17:29:11.824]                   function(frame = 1L) {
[17:29:11.824]                     if (is.function(sendCondition)) 
[17:29:11.824]                       return(sendCondition)
[17:29:11.824]                     ns <- getNamespace("parallel")
[17:29:11.824]                     if (exists("sendData", mode = "function", 
[17:29:11.824]                       envir = ns)) {
[17:29:11.824]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:11.824]                         envir = ns)
[17:29:11.824]                       envir <- sys.frame(frame)
[17:29:11.824]                       master <- NULL
[17:29:11.824]                       while (!identical(envir, .GlobalEnv) && 
[17:29:11.824]                         !identical(envir, emptyenv())) {
[17:29:11.824]                         if (exists("master", mode = "list", envir = envir, 
[17:29:11.824]                           inherits = FALSE)) {
[17:29:11.824]                           master <- get("master", mode = "list", 
[17:29:11.824]                             envir = envir, inherits = FALSE)
[17:29:11.824]                           if (inherits(master, c("SOCKnode", 
[17:29:11.824]                             "SOCK0node"))) {
[17:29:11.824]                             sendCondition <<- function(cond) {
[17:29:11.824]                               data <- list(type = "VALUE", value = cond, 
[17:29:11.824]                                 success = TRUE)
[17:29:11.824]                               parallel_sendData(master, data)
[17:29:11.824]                             }
[17:29:11.824]                             return(sendCondition)
[17:29:11.824]                           }
[17:29:11.824]                         }
[17:29:11.824]                         frame <- frame + 1L
[17:29:11.824]                         envir <- sys.frame(frame)
[17:29:11.824]                       }
[17:29:11.824]                     }
[17:29:11.824]                     sendCondition <<- function(cond) NULL
[17:29:11.824]                   }
[17:29:11.824]                 })
[17:29:11.824]                 withCallingHandlers({
[17:29:11.824]                   {
[17:29:11.824]                     Sys.sleep(0.5)
[17:29:11.824]                     list(a = 1, b = 42L)
[17:29:11.824]                   }
[17:29:11.824]                 }, immediateCondition = function(cond) {
[17:29:11.824]                   sendCondition <- ...future.makeSendCondition()
[17:29:11.824]                   sendCondition(cond)
[17:29:11.824]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:11.824]                   {
[17:29:11.824]                     inherits <- base::inherits
[17:29:11.824]                     invokeRestart <- base::invokeRestart
[17:29:11.824]                     is.null <- base::is.null
[17:29:11.824]                     muffled <- FALSE
[17:29:11.824]                     if (inherits(cond, "message")) {
[17:29:11.824]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:11.824]                       if (muffled) 
[17:29:11.824]                         invokeRestart("muffleMessage")
[17:29:11.824]                     }
[17:29:11.824]                     else if (inherits(cond, "warning")) {
[17:29:11.824]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:11.824]                       if (muffled) 
[17:29:11.824]                         invokeRestart("muffleWarning")
[17:29:11.824]                     }
[17:29:11.824]                     else if (inherits(cond, "condition")) {
[17:29:11.824]                       if (!is.null(pattern)) {
[17:29:11.824]                         computeRestarts <- base::computeRestarts
[17:29:11.824]                         grepl <- base::grepl
[17:29:11.824]                         restarts <- computeRestarts(cond)
[17:29:11.824]                         for (restart in restarts) {
[17:29:11.824]                           name <- restart$name
[17:29:11.824]                           if (is.null(name)) 
[17:29:11.824]                             next
[17:29:11.824]                           if (!grepl(pattern, name)) 
[17:29:11.824]                             next
[17:29:11.824]                           invokeRestart(restart)
[17:29:11.824]                           muffled <- TRUE
[17:29:11.824]                           break
[17:29:11.824]                         }
[17:29:11.824]                       }
[17:29:11.824]                     }
[17:29:11.824]                     invisible(muffled)
[17:29:11.824]                   }
[17:29:11.824]                   muffleCondition(cond)
[17:29:11.824]                 })
[17:29:11.824]             }))
[17:29:11.824]             future::FutureResult(value = ...future.value$value, 
[17:29:11.824]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:11.824]                   ...future.rng), globalenv = if (FALSE) 
[17:29:11.824]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:11.824]                     ...future.globalenv.names))
[17:29:11.824]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:11.824]         }, condition = base::local({
[17:29:11.824]             c <- base::c
[17:29:11.824]             inherits <- base::inherits
[17:29:11.824]             invokeRestart <- base::invokeRestart
[17:29:11.824]             length <- base::length
[17:29:11.824]             list <- base::list
[17:29:11.824]             seq.int <- base::seq.int
[17:29:11.824]             signalCondition <- base::signalCondition
[17:29:11.824]             sys.calls <- base::sys.calls
[17:29:11.824]             `[[` <- base::`[[`
[17:29:11.824]             `+` <- base::`+`
[17:29:11.824]             `<<-` <- base::`<<-`
[17:29:11.824]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:11.824]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:11.824]                   3L)]
[17:29:11.824]             }
[17:29:11.824]             function(cond) {
[17:29:11.824]                 is_error <- inherits(cond, "error")
[17:29:11.824]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:11.824]                   NULL)
[17:29:11.824]                 if (is_error) {
[17:29:11.824]                   sessionInformation <- function() {
[17:29:11.824]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:11.824]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:11.824]                       search = base::search(), system = base::Sys.info())
[17:29:11.824]                   }
[17:29:11.824]                   ...future.conditions[[length(...future.conditions) + 
[17:29:11.824]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:11.824]                     cond$call), session = sessionInformation(), 
[17:29:11.824]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:11.824]                   signalCondition(cond)
[17:29:11.824]                 }
[17:29:11.824]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:11.824]                 "immediateCondition"))) {
[17:29:11.824]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:11.824]                   ...future.conditions[[length(...future.conditions) + 
[17:29:11.824]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:11.824]                   if (TRUE && !signal) {
[17:29:11.824]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:11.824]                     {
[17:29:11.824]                       inherits <- base::inherits
[17:29:11.824]                       invokeRestart <- base::invokeRestart
[17:29:11.824]                       is.null <- base::is.null
[17:29:11.824]                       muffled <- FALSE
[17:29:11.824]                       if (inherits(cond, "message")) {
[17:29:11.824]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:11.824]                         if (muffled) 
[17:29:11.824]                           invokeRestart("muffleMessage")
[17:29:11.824]                       }
[17:29:11.824]                       else if (inherits(cond, "warning")) {
[17:29:11.824]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:11.824]                         if (muffled) 
[17:29:11.824]                           invokeRestart("muffleWarning")
[17:29:11.824]                       }
[17:29:11.824]                       else if (inherits(cond, "condition")) {
[17:29:11.824]                         if (!is.null(pattern)) {
[17:29:11.824]                           computeRestarts <- base::computeRestarts
[17:29:11.824]                           grepl <- base::grepl
[17:29:11.824]                           restarts <- computeRestarts(cond)
[17:29:11.824]                           for (restart in restarts) {
[17:29:11.824]                             name <- restart$name
[17:29:11.824]                             if (is.null(name)) 
[17:29:11.824]                               next
[17:29:11.824]                             if (!grepl(pattern, name)) 
[17:29:11.824]                               next
[17:29:11.824]                             invokeRestart(restart)
[17:29:11.824]                             muffled <- TRUE
[17:29:11.824]                             break
[17:29:11.824]                           }
[17:29:11.824]                         }
[17:29:11.824]                       }
[17:29:11.824]                       invisible(muffled)
[17:29:11.824]                     }
[17:29:11.824]                     muffleCondition(cond, pattern = "^muffle")
[17:29:11.824]                   }
[17:29:11.824]                 }
[17:29:11.824]                 else {
[17:29:11.824]                   if (TRUE) {
[17:29:11.824]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:11.824]                     {
[17:29:11.824]                       inherits <- base::inherits
[17:29:11.824]                       invokeRestart <- base::invokeRestart
[17:29:11.824]                       is.null <- base::is.null
[17:29:11.824]                       muffled <- FALSE
[17:29:11.824]                       if (inherits(cond, "message")) {
[17:29:11.824]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:11.824]                         if (muffled) 
[17:29:11.824]                           invokeRestart("muffleMessage")
[17:29:11.824]                       }
[17:29:11.824]                       else if (inherits(cond, "warning")) {
[17:29:11.824]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:11.824]                         if (muffled) 
[17:29:11.824]                           invokeRestart("muffleWarning")
[17:29:11.824]                       }
[17:29:11.824]                       else if (inherits(cond, "condition")) {
[17:29:11.824]                         if (!is.null(pattern)) {
[17:29:11.824]                           computeRestarts <- base::computeRestarts
[17:29:11.824]                           grepl <- base::grepl
[17:29:11.824]                           restarts <- computeRestarts(cond)
[17:29:11.824]                           for (restart in restarts) {
[17:29:11.824]                             name <- restart$name
[17:29:11.824]                             if (is.null(name)) 
[17:29:11.824]                               next
[17:29:11.824]                             if (!grepl(pattern, name)) 
[17:29:11.824]                               next
[17:29:11.824]                             invokeRestart(restart)
[17:29:11.824]                             muffled <- TRUE
[17:29:11.824]                             break
[17:29:11.824]                           }
[17:29:11.824]                         }
[17:29:11.824]                       }
[17:29:11.824]                       invisible(muffled)
[17:29:11.824]                     }
[17:29:11.824]                     muffleCondition(cond, pattern = "^muffle")
[17:29:11.824]                   }
[17:29:11.824]                 }
[17:29:11.824]             }
[17:29:11.824]         }))
[17:29:11.824]     }, error = function(ex) {
[17:29:11.824]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:11.824]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:11.824]                 ...future.rng), started = ...future.startTime, 
[17:29:11.824]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:11.824]             version = "1.8"), class = "FutureResult")
[17:29:11.824]     }, finally = {
[17:29:11.824]         if (!identical(...future.workdir, getwd())) 
[17:29:11.824]             setwd(...future.workdir)
[17:29:11.824]         {
[17:29:11.824]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:11.824]                 ...future.oldOptions$nwarnings <- NULL
[17:29:11.824]             }
[17:29:11.824]             base::options(...future.oldOptions)
[17:29:11.824]             if (.Platform$OS.type == "windows") {
[17:29:11.824]                 old_names <- names(...future.oldEnvVars)
[17:29:11.824]                 envs <- base::Sys.getenv()
[17:29:11.824]                 names <- names(envs)
[17:29:11.824]                 common <- intersect(names, old_names)
[17:29:11.824]                 added <- setdiff(names, old_names)
[17:29:11.824]                 removed <- setdiff(old_names, names)
[17:29:11.824]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:11.824]                   envs[common]]
[17:29:11.824]                 NAMES <- toupper(changed)
[17:29:11.824]                 args <- list()
[17:29:11.824]                 for (kk in seq_along(NAMES)) {
[17:29:11.824]                   name <- changed[[kk]]
[17:29:11.824]                   NAME <- NAMES[[kk]]
[17:29:11.824]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:11.824]                     next
[17:29:11.824]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:11.824]                 }
[17:29:11.824]                 NAMES <- toupper(added)
[17:29:11.824]                 for (kk in seq_along(NAMES)) {
[17:29:11.824]                   name <- added[[kk]]
[17:29:11.824]                   NAME <- NAMES[[kk]]
[17:29:11.824]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:11.824]                     next
[17:29:11.824]                   args[[name]] <- ""
[17:29:11.824]                 }
[17:29:11.824]                 NAMES <- toupper(removed)
[17:29:11.824]                 for (kk in seq_along(NAMES)) {
[17:29:11.824]                   name <- removed[[kk]]
[17:29:11.824]                   NAME <- NAMES[[kk]]
[17:29:11.824]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:11.824]                     next
[17:29:11.824]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:11.824]                 }
[17:29:11.824]                 if (length(args) > 0) 
[17:29:11.824]                   base::do.call(base::Sys.setenv, args = args)
[17:29:11.824]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:11.824]             }
[17:29:11.824]             else {
[17:29:11.824]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:11.824]             }
[17:29:11.824]             {
[17:29:11.824]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:11.824]                   0L) {
[17:29:11.824]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:11.824]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:11.824]                   base::options(opts)
[17:29:11.824]                 }
[17:29:11.824]                 {
[17:29:11.824]                   {
[17:29:11.824]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:11.824]                     NULL
[17:29:11.824]                   }
[17:29:11.824]                   options(future.plan = NULL)
[17:29:11.824]                   if (is.na(NA_character_)) 
[17:29:11.824]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:11.824]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:11.824]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:11.824]                     .init = FALSE)
[17:29:11.824]                 }
[17:29:11.824]             }
[17:29:11.824]         }
[17:29:11.824]     })
[17:29:11.824]     if (TRUE) {
[17:29:11.824]         base::sink(type = "output", split = FALSE)
[17:29:11.824]         if (TRUE) {
[17:29:11.824]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:11.824]         }
[17:29:11.824]         else {
[17:29:11.824]             ...future.result["stdout"] <- base::list(NULL)
[17:29:11.824]         }
[17:29:11.824]         base::close(...future.stdout)
[17:29:11.824]         ...future.stdout <- NULL
[17:29:11.824]     }
[17:29:11.824]     ...future.result$conditions <- ...future.conditions
[17:29:11.824]     ...future.result$finished <- base::Sys.time()
[17:29:11.824]     ...future.result
[17:29:11.824] }
[17:29:11.834] MultisessionFuture started
[17:29:11.834] - Launch lazy future ... done
[17:29:11.834] run() for 'MultisessionFuture' ... done
[17:29:12.380] receiveMessageFromWorker() for ClusterFuture ...
[17:29:12.381] - Validating connection of MultisessionFuture
[17:29:12.382] - received message: FutureResult
[17:29:12.382] - Received FutureResult
[17:29:12.383] - Erased future from FutureRegistry
[17:29:12.383] result() for ClusterFuture ...
[17:29:12.383] - result already collected: FutureResult
[17:29:12.384] result() for ClusterFuture ... done
[17:29:12.384] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:12.384] A MultisessionFuture was resolved (result was not collected)
[17:29:12.385] getGlobalsAndPackages() ...
[17:29:12.385] Searching for globals...
[17:29:12.388] - globals found: [3] '{', 'Sys.sleep', 'list'
[17:29:12.388] Searching for globals ... DONE
[17:29:12.389] Resolving globals: FALSE
[17:29:12.389] 
[17:29:12.390] 
[17:29:12.390] getGlobalsAndPackages() ... DONE
[17:29:12.391] run() for 'Future' ...
[17:29:12.391] - state: 'created'
[17:29:12.392] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:12.413] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:12.413] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:12.413]   - Field: 'node'
[17:29:12.414]   - Field: 'label'
[17:29:12.414]   - Field: 'local'
[17:29:12.414]   - Field: 'owner'
[17:29:12.415]   - Field: 'envir'
[17:29:12.415]   - Field: 'workers'
[17:29:12.415]   - Field: 'packages'
[17:29:12.416]   - Field: 'gc'
[17:29:12.416]   - Field: 'conditions'
[17:29:12.416]   - Field: 'persistent'
[17:29:12.417]   - Field: 'expr'
[17:29:12.417]   - Field: 'uuid'
[17:29:12.417]   - Field: 'seed'
[17:29:12.418]   - Field: 'version'
[17:29:12.418]   - Field: 'result'
[17:29:12.418]   - Field: 'asynchronous'
[17:29:12.419]   - Field: 'calls'
[17:29:12.419]   - Field: 'globals'
[17:29:12.419]   - Field: 'stdout'
[17:29:12.420]   - Field: 'earlySignal'
[17:29:12.420]   - Field: 'lazy'
[17:29:12.420]   - Field: 'state'
[17:29:12.421] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:12.421] - Launch lazy future ...
[17:29:12.422] Packages needed by the future expression (n = 0): <none>
[17:29:12.422] Packages needed by future strategies (n = 0): <none>
[17:29:12.423] {
[17:29:12.423]     {
[17:29:12.423]         {
[17:29:12.423]             ...future.startTime <- base::Sys.time()
[17:29:12.423]             {
[17:29:12.423]                 {
[17:29:12.423]                   {
[17:29:12.423]                     {
[17:29:12.423]                       base::local({
[17:29:12.423]                         has_future <- base::requireNamespace("future", 
[17:29:12.423]                           quietly = TRUE)
[17:29:12.423]                         if (has_future) {
[17:29:12.423]                           ns <- base::getNamespace("future")
[17:29:12.423]                           version <- ns[[".package"]][["version"]]
[17:29:12.423]                           if (is.null(version)) 
[17:29:12.423]                             version <- utils::packageVersion("future")
[17:29:12.423]                         }
[17:29:12.423]                         else {
[17:29:12.423]                           version <- NULL
[17:29:12.423]                         }
[17:29:12.423]                         if (!has_future || version < "1.8.0") {
[17:29:12.423]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:12.423]                             "", base::R.version$version.string), 
[17:29:12.423]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:12.423]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:12.423]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:12.423]                               "release", "version")], collapse = " "), 
[17:29:12.423]                             hostname = base::Sys.info()[["nodename"]])
[17:29:12.423]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:12.423]                             info)
[17:29:12.423]                           info <- base::paste(info, collapse = "; ")
[17:29:12.423]                           if (!has_future) {
[17:29:12.423]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:12.423]                               info)
[17:29:12.423]                           }
[17:29:12.423]                           else {
[17:29:12.423]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:12.423]                               info, version)
[17:29:12.423]                           }
[17:29:12.423]                           base::stop(msg)
[17:29:12.423]                         }
[17:29:12.423]                       })
[17:29:12.423]                     }
[17:29:12.423]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:12.423]                     base::options(mc.cores = 1L)
[17:29:12.423]                   }
[17:29:12.423]                   ...future.strategy.old <- future::plan("list")
[17:29:12.423]                   options(future.plan = NULL)
[17:29:12.423]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:12.423]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:12.423]                 }
[17:29:12.423]                 ...future.workdir <- getwd()
[17:29:12.423]             }
[17:29:12.423]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:12.423]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:12.423]         }
[17:29:12.423]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:12.423]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:12.423]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:12.423]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:12.423]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:12.423]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:12.423]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:12.423]             base::names(...future.oldOptions))
[17:29:12.423]     }
[17:29:12.423]     if (FALSE) {
[17:29:12.423]     }
[17:29:12.423]     else {
[17:29:12.423]         if (TRUE) {
[17:29:12.423]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:12.423]                 open = "w")
[17:29:12.423]         }
[17:29:12.423]         else {
[17:29:12.423]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:12.423]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:12.423]         }
[17:29:12.423]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:12.423]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:12.423]             base::sink(type = "output", split = FALSE)
[17:29:12.423]             base::close(...future.stdout)
[17:29:12.423]         }, add = TRUE)
[17:29:12.423]     }
[17:29:12.423]     ...future.frame <- base::sys.nframe()
[17:29:12.423]     ...future.conditions <- base::list()
[17:29:12.423]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:12.423]     if (FALSE) {
[17:29:12.423]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:12.423]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:12.423]     }
[17:29:12.423]     ...future.result <- base::tryCatch({
[17:29:12.423]         base::withCallingHandlers({
[17:29:12.423]             ...future.value <- base::withVisible(base::local({
[17:29:12.423]                 ...future.makeSendCondition <- base::local({
[17:29:12.423]                   sendCondition <- NULL
[17:29:12.423]                   function(frame = 1L) {
[17:29:12.423]                     if (is.function(sendCondition)) 
[17:29:12.423]                       return(sendCondition)
[17:29:12.423]                     ns <- getNamespace("parallel")
[17:29:12.423]                     if (exists("sendData", mode = "function", 
[17:29:12.423]                       envir = ns)) {
[17:29:12.423]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:12.423]                         envir = ns)
[17:29:12.423]                       envir <- sys.frame(frame)
[17:29:12.423]                       master <- NULL
[17:29:12.423]                       while (!identical(envir, .GlobalEnv) && 
[17:29:12.423]                         !identical(envir, emptyenv())) {
[17:29:12.423]                         if (exists("master", mode = "list", envir = envir, 
[17:29:12.423]                           inherits = FALSE)) {
[17:29:12.423]                           master <- get("master", mode = "list", 
[17:29:12.423]                             envir = envir, inherits = FALSE)
[17:29:12.423]                           if (inherits(master, c("SOCKnode", 
[17:29:12.423]                             "SOCK0node"))) {
[17:29:12.423]                             sendCondition <<- function(cond) {
[17:29:12.423]                               data <- list(type = "VALUE", value = cond, 
[17:29:12.423]                                 success = TRUE)
[17:29:12.423]                               parallel_sendData(master, data)
[17:29:12.423]                             }
[17:29:12.423]                             return(sendCondition)
[17:29:12.423]                           }
[17:29:12.423]                         }
[17:29:12.423]                         frame <- frame + 1L
[17:29:12.423]                         envir <- sys.frame(frame)
[17:29:12.423]                       }
[17:29:12.423]                     }
[17:29:12.423]                     sendCondition <<- function(cond) NULL
[17:29:12.423]                   }
[17:29:12.423]                 })
[17:29:12.423]                 withCallingHandlers({
[17:29:12.423]                   {
[17:29:12.423]                     Sys.sleep(0.5)
[17:29:12.423]                     list(a = 1, b = 42L)
[17:29:12.423]                   }
[17:29:12.423]                 }, immediateCondition = function(cond) {
[17:29:12.423]                   sendCondition <- ...future.makeSendCondition()
[17:29:12.423]                   sendCondition(cond)
[17:29:12.423]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:12.423]                   {
[17:29:12.423]                     inherits <- base::inherits
[17:29:12.423]                     invokeRestart <- base::invokeRestart
[17:29:12.423]                     is.null <- base::is.null
[17:29:12.423]                     muffled <- FALSE
[17:29:12.423]                     if (inherits(cond, "message")) {
[17:29:12.423]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:12.423]                       if (muffled) 
[17:29:12.423]                         invokeRestart("muffleMessage")
[17:29:12.423]                     }
[17:29:12.423]                     else if (inherits(cond, "warning")) {
[17:29:12.423]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:12.423]                       if (muffled) 
[17:29:12.423]                         invokeRestart("muffleWarning")
[17:29:12.423]                     }
[17:29:12.423]                     else if (inherits(cond, "condition")) {
[17:29:12.423]                       if (!is.null(pattern)) {
[17:29:12.423]                         computeRestarts <- base::computeRestarts
[17:29:12.423]                         grepl <- base::grepl
[17:29:12.423]                         restarts <- computeRestarts(cond)
[17:29:12.423]                         for (restart in restarts) {
[17:29:12.423]                           name <- restart$name
[17:29:12.423]                           if (is.null(name)) 
[17:29:12.423]                             next
[17:29:12.423]                           if (!grepl(pattern, name)) 
[17:29:12.423]                             next
[17:29:12.423]                           invokeRestart(restart)
[17:29:12.423]                           muffled <- TRUE
[17:29:12.423]                           break
[17:29:12.423]                         }
[17:29:12.423]                       }
[17:29:12.423]                     }
[17:29:12.423]                     invisible(muffled)
[17:29:12.423]                   }
[17:29:12.423]                   muffleCondition(cond)
[17:29:12.423]                 })
[17:29:12.423]             }))
[17:29:12.423]             future::FutureResult(value = ...future.value$value, 
[17:29:12.423]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:12.423]                   ...future.rng), globalenv = if (FALSE) 
[17:29:12.423]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:12.423]                     ...future.globalenv.names))
[17:29:12.423]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:12.423]         }, condition = base::local({
[17:29:12.423]             c <- base::c
[17:29:12.423]             inherits <- base::inherits
[17:29:12.423]             invokeRestart <- base::invokeRestart
[17:29:12.423]             length <- base::length
[17:29:12.423]             list <- base::list
[17:29:12.423]             seq.int <- base::seq.int
[17:29:12.423]             signalCondition <- base::signalCondition
[17:29:12.423]             sys.calls <- base::sys.calls
[17:29:12.423]             `[[` <- base::`[[`
[17:29:12.423]             `+` <- base::`+`
[17:29:12.423]             `<<-` <- base::`<<-`
[17:29:12.423]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:12.423]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:12.423]                   3L)]
[17:29:12.423]             }
[17:29:12.423]             function(cond) {
[17:29:12.423]                 is_error <- inherits(cond, "error")
[17:29:12.423]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:12.423]                   NULL)
[17:29:12.423]                 if (is_error) {
[17:29:12.423]                   sessionInformation <- function() {
[17:29:12.423]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:12.423]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:12.423]                       search = base::search(), system = base::Sys.info())
[17:29:12.423]                   }
[17:29:12.423]                   ...future.conditions[[length(...future.conditions) + 
[17:29:12.423]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:12.423]                     cond$call), session = sessionInformation(), 
[17:29:12.423]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:12.423]                   signalCondition(cond)
[17:29:12.423]                 }
[17:29:12.423]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:12.423]                 "immediateCondition"))) {
[17:29:12.423]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:12.423]                   ...future.conditions[[length(...future.conditions) + 
[17:29:12.423]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:12.423]                   if (TRUE && !signal) {
[17:29:12.423]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:12.423]                     {
[17:29:12.423]                       inherits <- base::inherits
[17:29:12.423]                       invokeRestart <- base::invokeRestart
[17:29:12.423]                       is.null <- base::is.null
[17:29:12.423]                       muffled <- FALSE
[17:29:12.423]                       if (inherits(cond, "message")) {
[17:29:12.423]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:12.423]                         if (muffled) 
[17:29:12.423]                           invokeRestart("muffleMessage")
[17:29:12.423]                       }
[17:29:12.423]                       else if (inherits(cond, "warning")) {
[17:29:12.423]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:12.423]                         if (muffled) 
[17:29:12.423]                           invokeRestart("muffleWarning")
[17:29:12.423]                       }
[17:29:12.423]                       else if (inherits(cond, "condition")) {
[17:29:12.423]                         if (!is.null(pattern)) {
[17:29:12.423]                           computeRestarts <- base::computeRestarts
[17:29:12.423]                           grepl <- base::grepl
[17:29:12.423]                           restarts <- computeRestarts(cond)
[17:29:12.423]                           for (restart in restarts) {
[17:29:12.423]                             name <- restart$name
[17:29:12.423]                             if (is.null(name)) 
[17:29:12.423]                               next
[17:29:12.423]                             if (!grepl(pattern, name)) 
[17:29:12.423]                               next
[17:29:12.423]                             invokeRestart(restart)
[17:29:12.423]                             muffled <- TRUE
[17:29:12.423]                             break
[17:29:12.423]                           }
[17:29:12.423]                         }
[17:29:12.423]                       }
[17:29:12.423]                       invisible(muffled)
[17:29:12.423]                     }
[17:29:12.423]                     muffleCondition(cond, pattern = "^muffle")
[17:29:12.423]                   }
[17:29:12.423]                 }
[17:29:12.423]                 else {
[17:29:12.423]                   if (TRUE) {
[17:29:12.423]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:12.423]                     {
[17:29:12.423]                       inherits <- base::inherits
[17:29:12.423]                       invokeRestart <- base::invokeRestart
[17:29:12.423]                       is.null <- base::is.null
[17:29:12.423]                       muffled <- FALSE
[17:29:12.423]                       if (inherits(cond, "message")) {
[17:29:12.423]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:12.423]                         if (muffled) 
[17:29:12.423]                           invokeRestart("muffleMessage")
[17:29:12.423]                       }
[17:29:12.423]                       else if (inherits(cond, "warning")) {
[17:29:12.423]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:12.423]                         if (muffled) 
[17:29:12.423]                           invokeRestart("muffleWarning")
[17:29:12.423]                       }
[17:29:12.423]                       else if (inherits(cond, "condition")) {
[17:29:12.423]                         if (!is.null(pattern)) {
[17:29:12.423]                           computeRestarts <- base::computeRestarts
[17:29:12.423]                           grepl <- base::grepl
[17:29:12.423]                           restarts <- computeRestarts(cond)
[17:29:12.423]                           for (restart in restarts) {
[17:29:12.423]                             name <- restart$name
[17:29:12.423]                             if (is.null(name)) 
[17:29:12.423]                               next
[17:29:12.423]                             if (!grepl(pattern, name)) 
[17:29:12.423]                               next
[17:29:12.423]                             invokeRestart(restart)
[17:29:12.423]                             muffled <- TRUE
[17:29:12.423]                             break
[17:29:12.423]                           }
[17:29:12.423]                         }
[17:29:12.423]                       }
[17:29:12.423]                       invisible(muffled)
[17:29:12.423]                     }
[17:29:12.423]                     muffleCondition(cond, pattern = "^muffle")
[17:29:12.423]                   }
[17:29:12.423]                 }
[17:29:12.423]             }
[17:29:12.423]         }))
[17:29:12.423]     }, error = function(ex) {
[17:29:12.423]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:12.423]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:12.423]                 ...future.rng), started = ...future.startTime, 
[17:29:12.423]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:12.423]             version = "1.8"), class = "FutureResult")
[17:29:12.423]     }, finally = {
[17:29:12.423]         if (!identical(...future.workdir, getwd())) 
[17:29:12.423]             setwd(...future.workdir)
[17:29:12.423]         {
[17:29:12.423]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:12.423]                 ...future.oldOptions$nwarnings <- NULL
[17:29:12.423]             }
[17:29:12.423]             base::options(...future.oldOptions)
[17:29:12.423]             if (.Platform$OS.type == "windows") {
[17:29:12.423]                 old_names <- names(...future.oldEnvVars)
[17:29:12.423]                 envs <- base::Sys.getenv()
[17:29:12.423]                 names <- names(envs)
[17:29:12.423]                 common <- intersect(names, old_names)
[17:29:12.423]                 added <- setdiff(names, old_names)
[17:29:12.423]                 removed <- setdiff(old_names, names)
[17:29:12.423]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:12.423]                   envs[common]]
[17:29:12.423]                 NAMES <- toupper(changed)
[17:29:12.423]                 args <- list()
[17:29:12.423]                 for (kk in seq_along(NAMES)) {
[17:29:12.423]                   name <- changed[[kk]]
[17:29:12.423]                   NAME <- NAMES[[kk]]
[17:29:12.423]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:12.423]                     next
[17:29:12.423]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:12.423]                 }
[17:29:12.423]                 NAMES <- toupper(added)
[17:29:12.423]                 for (kk in seq_along(NAMES)) {
[17:29:12.423]                   name <- added[[kk]]
[17:29:12.423]                   NAME <- NAMES[[kk]]
[17:29:12.423]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:12.423]                     next
[17:29:12.423]                   args[[name]] <- ""
[17:29:12.423]                 }
[17:29:12.423]                 NAMES <- toupper(removed)
[17:29:12.423]                 for (kk in seq_along(NAMES)) {
[17:29:12.423]                   name <- removed[[kk]]
[17:29:12.423]                   NAME <- NAMES[[kk]]
[17:29:12.423]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:12.423]                     next
[17:29:12.423]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:12.423]                 }
[17:29:12.423]                 if (length(args) > 0) 
[17:29:12.423]                   base::do.call(base::Sys.setenv, args = args)
[17:29:12.423]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:12.423]             }
[17:29:12.423]             else {
[17:29:12.423]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:12.423]             }
[17:29:12.423]             {
[17:29:12.423]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:12.423]                   0L) {
[17:29:12.423]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:12.423]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:12.423]                   base::options(opts)
[17:29:12.423]                 }
[17:29:12.423]                 {
[17:29:12.423]                   {
[17:29:12.423]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:12.423]                     NULL
[17:29:12.423]                   }
[17:29:12.423]                   options(future.plan = NULL)
[17:29:12.423]                   if (is.na(NA_character_)) 
[17:29:12.423]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:12.423]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:12.423]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:12.423]                     .init = FALSE)
[17:29:12.423]                 }
[17:29:12.423]             }
[17:29:12.423]         }
[17:29:12.423]     })
[17:29:12.423]     if (TRUE) {
[17:29:12.423]         base::sink(type = "output", split = FALSE)
[17:29:12.423]         if (TRUE) {
[17:29:12.423]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:12.423]         }
[17:29:12.423]         else {
[17:29:12.423]             ...future.result["stdout"] <- base::list(NULL)
[17:29:12.423]         }
[17:29:12.423]         base::close(...future.stdout)
[17:29:12.423]         ...future.stdout <- NULL
[17:29:12.423]     }
[17:29:12.423]     ...future.result$conditions <- ...future.conditions
[17:29:12.423]     ...future.result$finished <- base::Sys.time()
[17:29:12.423]     ...future.result
[17:29:12.423] }
[17:29:12.433] MultisessionFuture started
[17:29:12.433] - Launch lazy future ... done
[17:29:12.434] run() for 'MultisessionFuture' ... done
[17:29:12.969] receiveMessageFromWorker() for ClusterFuture ...
[17:29:12.970] - Validating connection of MultisessionFuture
[17:29:12.970] - received message: FutureResult
[17:29:12.970] - Received FutureResult
[17:29:12.971] - Erased future from FutureRegistry
[17:29:12.971] result() for ClusterFuture ...
[17:29:12.971] - result already collected: FutureResult
[17:29:12.972] result() for ClusterFuture ... done
[17:29:12.972] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:12.972] A MultisessionFuture was resolved (result was not collected)
- w/ exception ...
[17:29:12.973] getGlobalsAndPackages() ...
[17:29:12.973] Searching for globals...
[17:29:12.975] - globals found: [2] 'list', 'stop'
[17:29:12.975] Searching for globals ... DONE
[17:29:12.975] Resolving globals: FALSE
[17:29:12.976] 
[17:29:12.976] 
[17:29:12.977] getGlobalsAndPackages() ... DONE
[17:29:12.977] run() for 'Future' ...
[17:29:12.977] - state: 'created'
[17:29:12.978] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:13.000] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:13.000] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:13.000]   - Field: 'node'
[17:29:13.001]   - Field: 'label'
[17:29:13.001]   - Field: 'local'
[17:29:13.001]   - Field: 'owner'
[17:29:13.002]   - Field: 'envir'
[17:29:13.002]   - Field: 'workers'
[17:29:13.002]   - Field: 'packages'
[17:29:13.003]   - Field: 'gc'
[17:29:13.003]   - Field: 'conditions'
[17:29:13.003]   - Field: 'persistent'
[17:29:13.004]   - Field: 'expr'
[17:29:13.004]   - Field: 'uuid'
[17:29:13.004]   - Field: 'seed'
[17:29:13.004]   - Field: 'version'
[17:29:13.005]   - Field: 'result'
[17:29:13.005]   - Field: 'asynchronous'
[17:29:13.005]   - Field: 'calls'
[17:29:13.005]   - Field: 'globals'
[17:29:13.005]   - Field: 'stdout'
[17:29:13.006]   - Field: 'earlySignal'
[17:29:13.006]   - Field: 'lazy'
[17:29:13.006]   - Field: 'state'
[17:29:13.006] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:13.007] - Launch lazy future ...
[17:29:13.007] Packages needed by the future expression (n = 0): <none>
[17:29:13.008] Packages needed by future strategies (n = 0): <none>
[17:29:13.008] {
[17:29:13.008]     {
[17:29:13.008]         {
[17:29:13.008]             ...future.startTime <- base::Sys.time()
[17:29:13.008]             {
[17:29:13.008]                 {
[17:29:13.008]                   {
[17:29:13.008]                     {
[17:29:13.008]                       base::local({
[17:29:13.008]                         has_future <- base::requireNamespace("future", 
[17:29:13.008]                           quietly = TRUE)
[17:29:13.008]                         if (has_future) {
[17:29:13.008]                           ns <- base::getNamespace("future")
[17:29:13.008]                           version <- ns[[".package"]][["version"]]
[17:29:13.008]                           if (is.null(version)) 
[17:29:13.008]                             version <- utils::packageVersion("future")
[17:29:13.008]                         }
[17:29:13.008]                         else {
[17:29:13.008]                           version <- NULL
[17:29:13.008]                         }
[17:29:13.008]                         if (!has_future || version < "1.8.0") {
[17:29:13.008]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:13.008]                             "", base::R.version$version.string), 
[17:29:13.008]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:13.008]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:13.008]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:13.008]                               "release", "version")], collapse = " "), 
[17:29:13.008]                             hostname = base::Sys.info()[["nodename"]])
[17:29:13.008]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:13.008]                             info)
[17:29:13.008]                           info <- base::paste(info, collapse = "; ")
[17:29:13.008]                           if (!has_future) {
[17:29:13.008]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:13.008]                               info)
[17:29:13.008]                           }
[17:29:13.008]                           else {
[17:29:13.008]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:13.008]                               info, version)
[17:29:13.008]                           }
[17:29:13.008]                           base::stop(msg)
[17:29:13.008]                         }
[17:29:13.008]                       })
[17:29:13.008]                     }
[17:29:13.008]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:13.008]                     base::options(mc.cores = 1L)
[17:29:13.008]                   }
[17:29:13.008]                   ...future.strategy.old <- future::plan("list")
[17:29:13.008]                   options(future.plan = NULL)
[17:29:13.008]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:13.008]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:13.008]                 }
[17:29:13.008]                 ...future.workdir <- getwd()
[17:29:13.008]             }
[17:29:13.008]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:13.008]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:13.008]         }
[17:29:13.008]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:13.008]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:13.008]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:13.008]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:13.008]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:13.008]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:13.008]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:13.008]             base::names(...future.oldOptions))
[17:29:13.008]     }
[17:29:13.008]     if (FALSE) {
[17:29:13.008]     }
[17:29:13.008]     else {
[17:29:13.008]         if (TRUE) {
[17:29:13.008]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:13.008]                 open = "w")
[17:29:13.008]         }
[17:29:13.008]         else {
[17:29:13.008]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:13.008]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:13.008]         }
[17:29:13.008]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:13.008]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:13.008]             base::sink(type = "output", split = FALSE)
[17:29:13.008]             base::close(...future.stdout)
[17:29:13.008]         }, add = TRUE)
[17:29:13.008]     }
[17:29:13.008]     ...future.frame <- base::sys.nframe()
[17:29:13.008]     ...future.conditions <- base::list()
[17:29:13.008]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:13.008]     if (FALSE) {
[17:29:13.008]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:13.008]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:13.008]     }
[17:29:13.008]     ...future.result <- base::tryCatch({
[17:29:13.008]         base::withCallingHandlers({
[17:29:13.008]             ...future.value <- base::withVisible(base::local({
[17:29:13.008]                 ...future.makeSendCondition <- base::local({
[17:29:13.008]                   sendCondition <- NULL
[17:29:13.008]                   function(frame = 1L) {
[17:29:13.008]                     if (is.function(sendCondition)) 
[17:29:13.008]                       return(sendCondition)
[17:29:13.008]                     ns <- getNamespace("parallel")
[17:29:13.008]                     if (exists("sendData", mode = "function", 
[17:29:13.008]                       envir = ns)) {
[17:29:13.008]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:13.008]                         envir = ns)
[17:29:13.008]                       envir <- sys.frame(frame)
[17:29:13.008]                       master <- NULL
[17:29:13.008]                       while (!identical(envir, .GlobalEnv) && 
[17:29:13.008]                         !identical(envir, emptyenv())) {
[17:29:13.008]                         if (exists("master", mode = "list", envir = envir, 
[17:29:13.008]                           inherits = FALSE)) {
[17:29:13.008]                           master <- get("master", mode = "list", 
[17:29:13.008]                             envir = envir, inherits = FALSE)
[17:29:13.008]                           if (inherits(master, c("SOCKnode", 
[17:29:13.008]                             "SOCK0node"))) {
[17:29:13.008]                             sendCondition <<- function(cond) {
[17:29:13.008]                               data <- list(type = "VALUE", value = cond, 
[17:29:13.008]                                 success = TRUE)
[17:29:13.008]                               parallel_sendData(master, data)
[17:29:13.008]                             }
[17:29:13.008]                             return(sendCondition)
[17:29:13.008]                           }
[17:29:13.008]                         }
[17:29:13.008]                         frame <- frame + 1L
[17:29:13.008]                         envir <- sys.frame(frame)
[17:29:13.008]                       }
[17:29:13.008]                     }
[17:29:13.008]                     sendCondition <<- function(cond) NULL
[17:29:13.008]                   }
[17:29:13.008]                 })
[17:29:13.008]                 withCallingHandlers({
[17:29:13.008]                   list(a = 1, b = 42L, c = stop("Nah!"))
[17:29:13.008]                 }, immediateCondition = function(cond) {
[17:29:13.008]                   sendCondition <- ...future.makeSendCondition()
[17:29:13.008]                   sendCondition(cond)
[17:29:13.008]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:13.008]                   {
[17:29:13.008]                     inherits <- base::inherits
[17:29:13.008]                     invokeRestart <- base::invokeRestart
[17:29:13.008]                     is.null <- base::is.null
[17:29:13.008]                     muffled <- FALSE
[17:29:13.008]                     if (inherits(cond, "message")) {
[17:29:13.008]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:13.008]                       if (muffled) 
[17:29:13.008]                         invokeRestart("muffleMessage")
[17:29:13.008]                     }
[17:29:13.008]                     else if (inherits(cond, "warning")) {
[17:29:13.008]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:13.008]                       if (muffled) 
[17:29:13.008]                         invokeRestart("muffleWarning")
[17:29:13.008]                     }
[17:29:13.008]                     else if (inherits(cond, "condition")) {
[17:29:13.008]                       if (!is.null(pattern)) {
[17:29:13.008]                         computeRestarts <- base::computeRestarts
[17:29:13.008]                         grepl <- base::grepl
[17:29:13.008]                         restarts <- computeRestarts(cond)
[17:29:13.008]                         for (restart in restarts) {
[17:29:13.008]                           name <- restart$name
[17:29:13.008]                           if (is.null(name)) 
[17:29:13.008]                             next
[17:29:13.008]                           if (!grepl(pattern, name)) 
[17:29:13.008]                             next
[17:29:13.008]                           invokeRestart(restart)
[17:29:13.008]                           muffled <- TRUE
[17:29:13.008]                           break
[17:29:13.008]                         }
[17:29:13.008]                       }
[17:29:13.008]                     }
[17:29:13.008]                     invisible(muffled)
[17:29:13.008]                   }
[17:29:13.008]                   muffleCondition(cond)
[17:29:13.008]                 })
[17:29:13.008]             }))
[17:29:13.008]             future::FutureResult(value = ...future.value$value, 
[17:29:13.008]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:13.008]                   ...future.rng), globalenv = if (FALSE) 
[17:29:13.008]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:13.008]                     ...future.globalenv.names))
[17:29:13.008]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:13.008]         }, condition = base::local({
[17:29:13.008]             c <- base::c
[17:29:13.008]             inherits <- base::inherits
[17:29:13.008]             invokeRestart <- base::invokeRestart
[17:29:13.008]             length <- base::length
[17:29:13.008]             list <- base::list
[17:29:13.008]             seq.int <- base::seq.int
[17:29:13.008]             signalCondition <- base::signalCondition
[17:29:13.008]             sys.calls <- base::sys.calls
[17:29:13.008]             `[[` <- base::`[[`
[17:29:13.008]             `+` <- base::`+`
[17:29:13.008]             `<<-` <- base::`<<-`
[17:29:13.008]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:13.008]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:13.008]                   3L)]
[17:29:13.008]             }
[17:29:13.008]             function(cond) {
[17:29:13.008]                 is_error <- inherits(cond, "error")
[17:29:13.008]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:13.008]                   NULL)
[17:29:13.008]                 if (is_error) {
[17:29:13.008]                   sessionInformation <- function() {
[17:29:13.008]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:13.008]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:13.008]                       search = base::search(), system = base::Sys.info())
[17:29:13.008]                   }
[17:29:13.008]                   ...future.conditions[[length(...future.conditions) + 
[17:29:13.008]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:13.008]                     cond$call), session = sessionInformation(), 
[17:29:13.008]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:13.008]                   signalCondition(cond)
[17:29:13.008]                 }
[17:29:13.008]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:13.008]                 "immediateCondition"))) {
[17:29:13.008]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:13.008]                   ...future.conditions[[length(...future.conditions) + 
[17:29:13.008]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:13.008]                   if (TRUE && !signal) {
[17:29:13.008]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:13.008]                     {
[17:29:13.008]                       inherits <- base::inherits
[17:29:13.008]                       invokeRestart <- base::invokeRestart
[17:29:13.008]                       is.null <- base::is.null
[17:29:13.008]                       muffled <- FALSE
[17:29:13.008]                       if (inherits(cond, "message")) {
[17:29:13.008]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:13.008]                         if (muffled) 
[17:29:13.008]                           invokeRestart("muffleMessage")
[17:29:13.008]                       }
[17:29:13.008]                       else if (inherits(cond, "warning")) {
[17:29:13.008]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:13.008]                         if (muffled) 
[17:29:13.008]                           invokeRestart("muffleWarning")
[17:29:13.008]                       }
[17:29:13.008]                       else if (inherits(cond, "condition")) {
[17:29:13.008]                         if (!is.null(pattern)) {
[17:29:13.008]                           computeRestarts <- base::computeRestarts
[17:29:13.008]                           grepl <- base::grepl
[17:29:13.008]                           restarts <- computeRestarts(cond)
[17:29:13.008]                           for (restart in restarts) {
[17:29:13.008]                             name <- restart$name
[17:29:13.008]                             if (is.null(name)) 
[17:29:13.008]                               next
[17:29:13.008]                             if (!grepl(pattern, name)) 
[17:29:13.008]                               next
[17:29:13.008]                             invokeRestart(restart)
[17:29:13.008]                             muffled <- TRUE
[17:29:13.008]                             break
[17:29:13.008]                           }
[17:29:13.008]                         }
[17:29:13.008]                       }
[17:29:13.008]                       invisible(muffled)
[17:29:13.008]                     }
[17:29:13.008]                     muffleCondition(cond, pattern = "^muffle")
[17:29:13.008]                   }
[17:29:13.008]                 }
[17:29:13.008]                 else {
[17:29:13.008]                   if (TRUE) {
[17:29:13.008]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:13.008]                     {
[17:29:13.008]                       inherits <- base::inherits
[17:29:13.008]                       invokeRestart <- base::invokeRestart
[17:29:13.008]                       is.null <- base::is.null
[17:29:13.008]                       muffled <- FALSE
[17:29:13.008]                       if (inherits(cond, "message")) {
[17:29:13.008]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:13.008]                         if (muffled) 
[17:29:13.008]                           invokeRestart("muffleMessage")
[17:29:13.008]                       }
[17:29:13.008]                       else if (inherits(cond, "warning")) {
[17:29:13.008]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:13.008]                         if (muffled) 
[17:29:13.008]                           invokeRestart("muffleWarning")
[17:29:13.008]                       }
[17:29:13.008]                       else if (inherits(cond, "condition")) {
[17:29:13.008]                         if (!is.null(pattern)) {
[17:29:13.008]                           computeRestarts <- base::computeRestarts
[17:29:13.008]                           grepl <- base::grepl
[17:29:13.008]                           restarts <- computeRestarts(cond)
[17:29:13.008]                           for (restart in restarts) {
[17:29:13.008]                             name <- restart$name
[17:29:13.008]                             if (is.null(name)) 
[17:29:13.008]                               next
[17:29:13.008]                             if (!grepl(pattern, name)) 
[17:29:13.008]                               next
[17:29:13.008]                             invokeRestart(restart)
[17:29:13.008]                             muffled <- TRUE
[17:29:13.008]                             break
[17:29:13.008]                           }
[17:29:13.008]                         }
[17:29:13.008]                       }
[17:29:13.008]                       invisible(muffled)
[17:29:13.008]                     }
[17:29:13.008]                     muffleCondition(cond, pattern = "^muffle")
[17:29:13.008]                   }
[17:29:13.008]                 }
[17:29:13.008]             }
[17:29:13.008]         }))
[17:29:13.008]     }, error = function(ex) {
[17:29:13.008]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:13.008]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:13.008]                 ...future.rng), started = ...future.startTime, 
[17:29:13.008]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:13.008]             version = "1.8"), class = "FutureResult")
[17:29:13.008]     }, finally = {
[17:29:13.008]         if (!identical(...future.workdir, getwd())) 
[17:29:13.008]             setwd(...future.workdir)
[17:29:13.008]         {
[17:29:13.008]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:13.008]                 ...future.oldOptions$nwarnings <- NULL
[17:29:13.008]             }
[17:29:13.008]             base::options(...future.oldOptions)
[17:29:13.008]             if (.Platform$OS.type == "windows") {
[17:29:13.008]                 old_names <- names(...future.oldEnvVars)
[17:29:13.008]                 envs <- base::Sys.getenv()
[17:29:13.008]                 names <- names(envs)
[17:29:13.008]                 common <- intersect(names, old_names)
[17:29:13.008]                 added <- setdiff(names, old_names)
[17:29:13.008]                 removed <- setdiff(old_names, names)
[17:29:13.008]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:13.008]                   envs[common]]
[17:29:13.008]                 NAMES <- toupper(changed)
[17:29:13.008]                 args <- list()
[17:29:13.008]                 for (kk in seq_along(NAMES)) {
[17:29:13.008]                   name <- changed[[kk]]
[17:29:13.008]                   NAME <- NAMES[[kk]]
[17:29:13.008]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:13.008]                     next
[17:29:13.008]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:13.008]                 }
[17:29:13.008]                 NAMES <- toupper(added)
[17:29:13.008]                 for (kk in seq_along(NAMES)) {
[17:29:13.008]                   name <- added[[kk]]
[17:29:13.008]                   NAME <- NAMES[[kk]]
[17:29:13.008]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:13.008]                     next
[17:29:13.008]                   args[[name]] <- ""
[17:29:13.008]                 }
[17:29:13.008]                 NAMES <- toupper(removed)
[17:29:13.008]                 for (kk in seq_along(NAMES)) {
[17:29:13.008]                   name <- removed[[kk]]
[17:29:13.008]                   NAME <- NAMES[[kk]]
[17:29:13.008]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:13.008]                     next
[17:29:13.008]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:13.008]                 }
[17:29:13.008]                 if (length(args) > 0) 
[17:29:13.008]                   base::do.call(base::Sys.setenv, args = args)
[17:29:13.008]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:13.008]             }
[17:29:13.008]             else {
[17:29:13.008]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:13.008]             }
[17:29:13.008]             {
[17:29:13.008]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:13.008]                   0L) {
[17:29:13.008]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:13.008]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:13.008]                   base::options(opts)
[17:29:13.008]                 }
[17:29:13.008]                 {
[17:29:13.008]                   {
[17:29:13.008]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:13.008]                     NULL
[17:29:13.008]                   }
[17:29:13.008]                   options(future.plan = NULL)
[17:29:13.008]                   if (is.na(NA_character_)) 
[17:29:13.008]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:13.008]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:13.008]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:13.008]                     .init = FALSE)
[17:29:13.008]                 }
[17:29:13.008]             }
[17:29:13.008]         }
[17:29:13.008]     })
[17:29:13.008]     if (TRUE) {
[17:29:13.008]         base::sink(type = "output", split = FALSE)
[17:29:13.008]         if (TRUE) {
[17:29:13.008]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:13.008]         }
[17:29:13.008]         else {
[17:29:13.008]             ...future.result["stdout"] <- base::list(NULL)
[17:29:13.008]         }
[17:29:13.008]         base::close(...future.stdout)
[17:29:13.008]         ...future.stdout <- NULL
[17:29:13.008]     }
[17:29:13.008]     ...future.result$conditions <- ...future.conditions
[17:29:13.008]     ...future.result$finished <- base::Sys.time()
[17:29:13.008]     ...future.result
[17:29:13.008] }
[17:29:13.016] MultisessionFuture started
[17:29:13.016] - Launch lazy future ... done
[17:29:13.016] run() for 'MultisessionFuture' ... done
[17:29:13.040] receiveMessageFromWorker() for ClusterFuture ...
[17:29:13.041] - Validating connection of MultisessionFuture
[17:29:13.041] - received message: FutureResult
[17:29:13.042] - Received FutureResult
[17:29:13.042] - Erased future from FutureRegistry
[17:29:13.042] result() for ClusterFuture ...
[17:29:13.043] - result already collected: FutureResult
[17:29:13.043] result() for ClusterFuture ... done
[17:29:13.043] signalConditions() ...
[17:29:13.043]  - include = 'immediateCondition'
[17:29:13.044]  - exclude = 
[17:29:13.044]  - resignal = FALSE
[17:29:13.044]  - Number of conditions: 1
[17:29:13.044] signalConditions() ... done
[17:29:13.045] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:13.045] A MultisessionFuture was resolved (result was not collected)
[17:29:13.045] getGlobalsAndPackages() ...
[17:29:13.045] Searching for globals...
[17:29:13.047] - globals found: [2] 'list', 'stop'
[17:29:13.047] Searching for globals ... DONE
[17:29:13.047] Resolving globals: FALSE
[17:29:13.048] 
[17:29:13.048] 
[17:29:13.048] getGlobalsAndPackages() ... DONE
[17:29:13.049] run() for 'Future' ...
[17:29:13.049] - state: 'created'
[17:29:13.049] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:13.070] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:13.070] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:13.071]   - Field: 'node'
[17:29:13.071]   - Field: 'label'
[17:29:13.071]   - Field: 'local'
[17:29:13.071]   - Field: 'owner'
[17:29:13.072]   - Field: 'envir'
[17:29:13.072]   - Field: 'workers'
[17:29:13.072]   - Field: 'packages'
[17:29:13.072]   - Field: 'gc'
[17:29:13.073]   - Field: 'conditions'
[17:29:13.073]   - Field: 'persistent'
[17:29:13.073]   - Field: 'expr'
[17:29:13.074]   - Field: 'uuid'
[17:29:13.074]   - Field: 'seed'
[17:29:13.074]   - Field: 'version'
[17:29:13.074]   - Field: 'result'
[17:29:13.075]   - Field: 'asynchronous'
[17:29:13.075]   - Field: 'calls'
[17:29:13.075]   - Field: 'globals'
[17:29:13.075]   - Field: 'stdout'
[17:29:13.076]   - Field: 'earlySignal'
[17:29:13.076]   - Field: 'lazy'
[17:29:13.076]   - Field: 'state'
[17:29:13.076] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:13.077] - Launch lazy future ...
[17:29:13.077] Packages needed by the future expression (n = 0): <none>
[17:29:13.078] Packages needed by future strategies (n = 0): <none>
[17:29:13.079] {
[17:29:13.079]     {
[17:29:13.079]         {
[17:29:13.079]             ...future.startTime <- base::Sys.time()
[17:29:13.079]             {
[17:29:13.079]                 {
[17:29:13.079]                   {
[17:29:13.079]                     {
[17:29:13.079]                       base::local({
[17:29:13.079]                         has_future <- base::requireNamespace("future", 
[17:29:13.079]                           quietly = TRUE)
[17:29:13.079]                         if (has_future) {
[17:29:13.079]                           ns <- base::getNamespace("future")
[17:29:13.079]                           version <- ns[[".package"]][["version"]]
[17:29:13.079]                           if (is.null(version)) 
[17:29:13.079]                             version <- utils::packageVersion("future")
[17:29:13.079]                         }
[17:29:13.079]                         else {
[17:29:13.079]                           version <- NULL
[17:29:13.079]                         }
[17:29:13.079]                         if (!has_future || version < "1.8.0") {
[17:29:13.079]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:13.079]                             "", base::R.version$version.string), 
[17:29:13.079]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:13.079]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:13.079]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:13.079]                               "release", "version")], collapse = " "), 
[17:29:13.079]                             hostname = base::Sys.info()[["nodename"]])
[17:29:13.079]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:13.079]                             info)
[17:29:13.079]                           info <- base::paste(info, collapse = "; ")
[17:29:13.079]                           if (!has_future) {
[17:29:13.079]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:13.079]                               info)
[17:29:13.079]                           }
[17:29:13.079]                           else {
[17:29:13.079]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:13.079]                               info, version)
[17:29:13.079]                           }
[17:29:13.079]                           base::stop(msg)
[17:29:13.079]                         }
[17:29:13.079]                       })
[17:29:13.079]                     }
[17:29:13.079]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:13.079]                     base::options(mc.cores = 1L)
[17:29:13.079]                   }
[17:29:13.079]                   ...future.strategy.old <- future::plan("list")
[17:29:13.079]                   options(future.plan = NULL)
[17:29:13.079]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:13.079]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:13.079]                 }
[17:29:13.079]                 ...future.workdir <- getwd()
[17:29:13.079]             }
[17:29:13.079]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:13.079]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:13.079]         }
[17:29:13.079]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:13.079]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:13.079]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:13.079]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:13.079]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:13.079]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:13.079]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:13.079]             base::names(...future.oldOptions))
[17:29:13.079]     }
[17:29:13.079]     if (FALSE) {
[17:29:13.079]     }
[17:29:13.079]     else {
[17:29:13.079]         if (TRUE) {
[17:29:13.079]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:13.079]                 open = "w")
[17:29:13.079]         }
[17:29:13.079]         else {
[17:29:13.079]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:13.079]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:13.079]         }
[17:29:13.079]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:13.079]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:13.079]             base::sink(type = "output", split = FALSE)
[17:29:13.079]             base::close(...future.stdout)
[17:29:13.079]         }, add = TRUE)
[17:29:13.079]     }
[17:29:13.079]     ...future.frame <- base::sys.nframe()
[17:29:13.079]     ...future.conditions <- base::list()
[17:29:13.079]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:13.079]     if (FALSE) {
[17:29:13.079]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:13.079]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:13.079]     }
[17:29:13.079]     ...future.result <- base::tryCatch({
[17:29:13.079]         base::withCallingHandlers({
[17:29:13.079]             ...future.value <- base::withVisible(base::local({
[17:29:13.079]                 ...future.makeSendCondition <- base::local({
[17:29:13.079]                   sendCondition <- NULL
[17:29:13.079]                   function(frame = 1L) {
[17:29:13.079]                     if (is.function(sendCondition)) 
[17:29:13.079]                       return(sendCondition)
[17:29:13.079]                     ns <- getNamespace("parallel")
[17:29:13.079]                     if (exists("sendData", mode = "function", 
[17:29:13.079]                       envir = ns)) {
[17:29:13.079]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:13.079]                         envir = ns)
[17:29:13.079]                       envir <- sys.frame(frame)
[17:29:13.079]                       master <- NULL
[17:29:13.079]                       while (!identical(envir, .GlobalEnv) && 
[17:29:13.079]                         !identical(envir, emptyenv())) {
[17:29:13.079]                         if (exists("master", mode = "list", envir = envir, 
[17:29:13.079]                           inherits = FALSE)) {
[17:29:13.079]                           master <- get("master", mode = "list", 
[17:29:13.079]                             envir = envir, inherits = FALSE)
[17:29:13.079]                           if (inherits(master, c("SOCKnode", 
[17:29:13.079]                             "SOCK0node"))) {
[17:29:13.079]                             sendCondition <<- function(cond) {
[17:29:13.079]                               data <- list(type = "VALUE", value = cond, 
[17:29:13.079]                                 success = TRUE)
[17:29:13.079]                               parallel_sendData(master, data)
[17:29:13.079]                             }
[17:29:13.079]                             return(sendCondition)
[17:29:13.079]                           }
[17:29:13.079]                         }
[17:29:13.079]                         frame <- frame + 1L
[17:29:13.079]                         envir <- sys.frame(frame)
[17:29:13.079]                       }
[17:29:13.079]                     }
[17:29:13.079]                     sendCondition <<- function(cond) NULL
[17:29:13.079]                   }
[17:29:13.079]                 })
[17:29:13.079]                 withCallingHandlers({
[17:29:13.079]                   list(a = 1, b = 42L, c = stop("Nah!"))
[17:29:13.079]                 }, immediateCondition = function(cond) {
[17:29:13.079]                   sendCondition <- ...future.makeSendCondition()
[17:29:13.079]                   sendCondition(cond)
[17:29:13.079]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:13.079]                   {
[17:29:13.079]                     inherits <- base::inherits
[17:29:13.079]                     invokeRestart <- base::invokeRestart
[17:29:13.079]                     is.null <- base::is.null
[17:29:13.079]                     muffled <- FALSE
[17:29:13.079]                     if (inherits(cond, "message")) {
[17:29:13.079]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:13.079]                       if (muffled) 
[17:29:13.079]                         invokeRestart("muffleMessage")
[17:29:13.079]                     }
[17:29:13.079]                     else if (inherits(cond, "warning")) {
[17:29:13.079]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:13.079]                       if (muffled) 
[17:29:13.079]                         invokeRestart("muffleWarning")
[17:29:13.079]                     }
[17:29:13.079]                     else if (inherits(cond, "condition")) {
[17:29:13.079]                       if (!is.null(pattern)) {
[17:29:13.079]                         computeRestarts <- base::computeRestarts
[17:29:13.079]                         grepl <- base::grepl
[17:29:13.079]                         restarts <- computeRestarts(cond)
[17:29:13.079]                         for (restart in restarts) {
[17:29:13.079]                           name <- restart$name
[17:29:13.079]                           if (is.null(name)) 
[17:29:13.079]                             next
[17:29:13.079]                           if (!grepl(pattern, name)) 
[17:29:13.079]                             next
[17:29:13.079]                           invokeRestart(restart)
[17:29:13.079]                           muffled <- TRUE
[17:29:13.079]                           break
[17:29:13.079]                         }
[17:29:13.079]                       }
[17:29:13.079]                     }
[17:29:13.079]                     invisible(muffled)
[17:29:13.079]                   }
[17:29:13.079]                   muffleCondition(cond)
[17:29:13.079]                 })
[17:29:13.079]             }))
[17:29:13.079]             future::FutureResult(value = ...future.value$value, 
[17:29:13.079]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:13.079]                   ...future.rng), globalenv = if (FALSE) 
[17:29:13.079]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:13.079]                     ...future.globalenv.names))
[17:29:13.079]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:13.079]         }, condition = base::local({
[17:29:13.079]             c <- base::c
[17:29:13.079]             inherits <- base::inherits
[17:29:13.079]             invokeRestart <- base::invokeRestart
[17:29:13.079]             length <- base::length
[17:29:13.079]             list <- base::list
[17:29:13.079]             seq.int <- base::seq.int
[17:29:13.079]             signalCondition <- base::signalCondition
[17:29:13.079]             sys.calls <- base::sys.calls
[17:29:13.079]             `[[` <- base::`[[`
[17:29:13.079]             `+` <- base::`+`
[17:29:13.079]             `<<-` <- base::`<<-`
[17:29:13.079]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:13.079]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:13.079]                   3L)]
[17:29:13.079]             }
[17:29:13.079]             function(cond) {
[17:29:13.079]                 is_error <- inherits(cond, "error")
[17:29:13.079]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:13.079]                   NULL)
[17:29:13.079]                 if (is_error) {
[17:29:13.079]                   sessionInformation <- function() {
[17:29:13.079]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:13.079]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:13.079]                       search = base::search(), system = base::Sys.info())
[17:29:13.079]                   }
[17:29:13.079]                   ...future.conditions[[length(...future.conditions) + 
[17:29:13.079]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:13.079]                     cond$call), session = sessionInformation(), 
[17:29:13.079]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:13.079]                   signalCondition(cond)
[17:29:13.079]                 }
[17:29:13.079]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:13.079]                 "immediateCondition"))) {
[17:29:13.079]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:13.079]                   ...future.conditions[[length(...future.conditions) + 
[17:29:13.079]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:13.079]                   if (TRUE && !signal) {
[17:29:13.079]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:13.079]                     {
[17:29:13.079]                       inherits <- base::inherits
[17:29:13.079]                       invokeRestart <- base::invokeRestart
[17:29:13.079]                       is.null <- base::is.null
[17:29:13.079]                       muffled <- FALSE
[17:29:13.079]                       if (inherits(cond, "message")) {
[17:29:13.079]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:13.079]                         if (muffled) 
[17:29:13.079]                           invokeRestart("muffleMessage")
[17:29:13.079]                       }
[17:29:13.079]                       else if (inherits(cond, "warning")) {
[17:29:13.079]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:13.079]                         if (muffled) 
[17:29:13.079]                           invokeRestart("muffleWarning")
[17:29:13.079]                       }
[17:29:13.079]                       else if (inherits(cond, "condition")) {
[17:29:13.079]                         if (!is.null(pattern)) {
[17:29:13.079]                           computeRestarts <- base::computeRestarts
[17:29:13.079]                           grepl <- base::grepl
[17:29:13.079]                           restarts <- computeRestarts(cond)
[17:29:13.079]                           for (restart in restarts) {
[17:29:13.079]                             name <- restart$name
[17:29:13.079]                             if (is.null(name)) 
[17:29:13.079]                               next
[17:29:13.079]                             if (!grepl(pattern, name)) 
[17:29:13.079]                               next
[17:29:13.079]                             invokeRestart(restart)
[17:29:13.079]                             muffled <- TRUE
[17:29:13.079]                             break
[17:29:13.079]                           }
[17:29:13.079]                         }
[17:29:13.079]                       }
[17:29:13.079]                       invisible(muffled)
[17:29:13.079]                     }
[17:29:13.079]                     muffleCondition(cond, pattern = "^muffle")
[17:29:13.079]                   }
[17:29:13.079]                 }
[17:29:13.079]                 else {
[17:29:13.079]                   if (TRUE) {
[17:29:13.079]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:13.079]                     {
[17:29:13.079]                       inherits <- base::inherits
[17:29:13.079]                       invokeRestart <- base::invokeRestart
[17:29:13.079]                       is.null <- base::is.null
[17:29:13.079]                       muffled <- FALSE
[17:29:13.079]                       if (inherits(cond, "message")) {
[17:29:13.079]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:13.079]                         if (muffled) 
[17:29:13.079]                           invokeRestart("muffleMessage")
[17:29:13.079]                       }
[17:29:13.079]                       else if (inherits(cond, "warning")) {
[17:29:13.079]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:13.079]                         if (muffled) 
[17:29:13.079]                           invokeRestart("muffleWarning")
[17:29:13.079]                       }
[17:29:13.079]                       else if (inherits(cond, "condition")) {
[17:29:13.079]                         if (!is.null(pattern)) {
[17:29:13.079]                           computeRestarts <- base::computeRestarts
[17:29:13.079]                           grepl <- base::grepl
[17:29:13.079]                           restarts <- computeRestarts(cond)
[17:29:13.079]                           for (restart in restarts) {
[17:29:13.079]                             name <- restart$name
[17:29:13.079]                             if (is.null(name)) 
[17:29:13.079]                               next
[17:29:13.079]                             if (!grepl(pattern, name)) 
[17:29:13.079]                               next
[17:29:13.079]                             invokeRestart(restart)
[17:29:13.079]                             muffled <- TRUE
[17:29:13.079]                             break
[17:29:13.079]                           }
[17:29:13.079]                         }
[17:29:13.079]                       }
[17:29:13.079]                       invisible(muffled)
[17:29:13.079]                     }
[17:29:13.079]                     muffleCondition(cond, pattern = "^muffle")
[17:29:13.079]                   }
[17:29:13.079]                 }
[17:29:13.079]             }
[17:29:13.079]         }))
[17:29:13.079]     }, error = function(ex) {
[17:29:13.079]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:13.079]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:13.079]                 ...future.rng), started = ...future.startTime, 
[17:29:13.079]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:13.079]             version = "1.8"), class = "FutureResult")
[17:29:13.079]     }, finally = {
[17:29:13.079]         if (!identical(...future.workdir, getwd())) 
[17:29:13.079]             setwd(...future.workdir)
[17:29:13.079]         {
[17:29:13.079]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:13.079]                 ...future.oldOptions$nwarnings <- NULL
[17:29:13.079]             }
[17:29:13.079]             base::options(...future.oldOptions)
[17:29:13.079]             if (.Platform$OS.type == "windows") {
[17:29:13.079]                 old_names <- names(...future.oldEnvVars)
[17:29:13.079]                 envs <- base::Sys.getenv()
[17:29:13.079]                 names <- names(envs)
[17:29:13.079]                 common <- intersect(names, old_names)
[17:29:13.079]                 added <- setdiff(names, old_names)
[17:29:13.079]                 removed <- setdiff(old_names, names)
[17:29:13.079]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:13.079]                   envs[common]]
[17:29:13.079]                 NAMES <- toupper(changed)
[17:29:13.079]                 args <- list()
[17:29:13.079]                 for (kk in seq_along(NAMES)) {
[17:29:13.079]                   name <- changed[[kk]]
[17:29:13.079]                   NAME <- NAMES[[kk]]
[17:29:13.079]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:13.079]                     next
[17:29:13.079]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:13.079]                 }
[17:29:13.079]                 NAMES <- toupper(added)
[17:29:13.079]                 for (kk in seq_along(NAMES)) {
[17:29:13.079]                   name <- added[[kk]]
[17:29:13.079]                   NAME <- NAMES[[kk]]
[17:29:13.079]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:13.079]                     next
[17:29:13.079]                   args[[name]] <- ""
[17:29:13.079]                 }
[17:29:13.079]                 NAMES <- toupper(removed)
[17:29:13.079]                 for (kk in seq_along(NAMES)) {
[17:29:13.079]                   name <- removed[[kk]]
[17:29:13.079]                   NAME <- NAMES[[kk]]
[17:29:13.079]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:13.079]                     next
[17:29:13.079]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:13.079]                 }
[17:29:13.079]                 if (length(args) > 0) 
[17:29:13.079]                   base::do.call(base::Sys.setenv, args = args)
[17:29:13.079]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:13.079]             }
[17:29:13.079]             else {
[17:29:13.079]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:13.079]             }
[17:29:13.079]             {
[17:29:13.079]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:13.079]                   0L) {
[17:29:13.079]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:13.079]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:13.079]                   base::options(opts)
[17:29:13.079]                 }
[17:29:13.079]                 {
[17:29:13.079]                   {
[17:29:13.079]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:13.079]                     NULL
[17:29:13.079]                   }
[17:29:13.079]                   options(future.plan = NULL)
[17:29:13.079]                   if (is.na(NA_character_)) 
[17:29:13.079]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:13.079]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:13.079]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:13.079]                     .init = FALSE)
[17:29:13.079]                 }
[17:29:13.079]             }
[17:29:13.079]         }
[17:29:13.079]     })
[17:29:13.079]     if (TRUE) {
[17:29:13.079]         base::sink(type = "output", split = FALSE)
[17:29:13.079]         if (TRUE) {
[17:29:13.079]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:13.079]         }
[17:29:13.079]         else {
[17:29:13.079]             ...future.result["stdout"] <- base::list(NULL)
[17:29:13.079]         }
[17:29:13.079]         base::close(...future.stdout)
[17:29:13.079]         ...future.stdout <- NULL
[17:29:13.079]     }
[17:29:13.079]     ...future.result$conditions <- ...future.conditions
[17:29:13.079]     ...future.result$finished <- base::Sys.time()
[17:29:13.079]     ...future.result
[17:29:13.079] }
[17:29:13.088] MultisessionFuture started
[17:29:13.088] - Launch lazy future ... done
[17:29:13.088] run() for 'MultisessionFuture' ... done
[17:29:13.114] receiveMessageFromWorker() for ClusterFuture ...
[17:29:13.114] - Validating connection of MultisessionFuture
[17:29:13.115] - received message: FutureResult
[17:29:13.116] - Received FutureResult
[17:29:13.116] - Erased future from FutureRegistry
[17:29:13.116] result() for ClusterFuture ...
[17:29:13.117] - result already collected: FutureResult
[17:29:13.117] result() for ClusterFuture ... done
[17:29:13.117] signalConditions() ...
[17:29:13.118]  - include = 'immediateCondition'
[17:29:13.118]  - exclude = 
[17:29:13.118]  - resignal = FALSE
[17:29:13.119]  - Number of conditions: 1
[17:29:13.119] signalConditions() ... done
[17:29:13.119] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:13.120] A MultisessionFuture was resolved (result was not collected)
- result = FALSE, recursive = 1 ... DONE
- result = FALSE, recursive = 2 ...
[17:29:13.120] getGlobalsAndPackages() ...
[17:29:13.121] Searching for globals...
[17:29:13.123] - globals found: [3] '{', 'Sys.sleep', 'list'
[17:29:13.124] Searching for globals ... DONE
[17:29:13.124] Resolving globals: FALSE
[17:29:13.124] 
[17:29:13.125] 
[17:29:13.125] getGlobalsAndPackages() ... DONE
[17:29:13.125] run() for 'Future' ...
[17:29:13.126] - state: 'created'
[17:29:13.126] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:13.147] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:13.147] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:13.147]   - Field: 'node'
[17:29:13.148]   - Field: 'label'
[17:29:13.148]   - Field: 'local'
[17:29:13.148]   - Field: 'owner'
[17:29:13.148]   - Field: 'envir'
[17:29:13.149]   - Field: 'workers'
[17:29:13.149]   - Field: 'packages'
[17:29:13.149]   - Field: 'gc'
[17:29:13.150]   - Field: 'conditions'
[17:29:13.150]   - Field: 'persistent'
[17:29:13.150]   - Field: 'expr'
[17:29:13.150]   - Field: 'uuid'
[17:29:13.151]   - Field: 'seed'
[17:29:13.151]   - Field: 'version'
[17:29:13.151]   - Field: 'result'
[17:29:13.152]   - Field: 'asynchronous'
[17:29:13.152]   - Field: 'calls'
[17:29:13.152]   - Field: 'globals'
[17:29:13.152]   - Field: 'stdout'
[17:29:13.153]   - Field: 'earlySignal'
[17:29:13.153]   - Field: 'lazy'
[17:29:13.153]   - Field: 'state'
[17:29:13.154] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:13.154] - Launch lazy future ...
[17:29:13.154] Packages needed by the future expression (n = 0): <none>
[17:29:13.155] Packages needed by future strategies (n = 0): <none>
[17:29:13.156] {
[17:29:13.156]     {
[17:29:13.156]         {
[17:29:13.156]             ...future.startTime <- base::Sys.time()
[17:29:13.156]             {
[17:29:13.156]                 {
[17:29:13.156]                   {
[17:29:13.156]                     {
[17:29:13.156]                       base::local({
[17:29:13.156]                         has_future <- base::requireNamespace("future", 
[17:29:13.156]                           quietly = TRUE)
[17:29:13.156]                         if (has_future) {
[17:29:13.156]                           ns <- base::getNamespace("future")
[17:29:13.156]                           version <- ns[[".package"]][["version"]]
[17:29:13.156]                           if (is.null(version)) 
[17:29:13.156]                             version <- utils::packageVersion("future")
[17:29:13.156]                         }
[17:29:13.156]                         else {
[17:29:13.156]                           version <- NULL
[17:29:13.156]                         }
[17:29:13.156]                         if (!has_future || version < "1.8.0") {
[17:29:13.156]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:13.156]                             "", base::R.version$version.string), 
[17:29:13.156]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:13.156]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:13.156]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:13.156]                               "release", "version")], collapse = " "), 
[17:29:13.156]                             hostname = base::Sys.info()[["nodename"]])
[17:29:13.156]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:13.156]                             info)
[17:29:13.156]                           info <- base::paste(info, collapse = "; ")
[17:29:13.156]                           if (!has_future) {
[17:29:13.156]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:13.156]                               info)
[17:29:13.156]                           }
[17:29:13.156]                           else {
[17:29:13.156]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:13.156]                               info, version)
[17:29:13.156]                           }
[17:29:13.156]                           base::stop(msg)
[17:29:13.156]                         }
[17:29:13.156]                       })
[17:29:13.156]                     }
[17:29:13.156]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:13.156]                     base::options(mc.cores = 1L)
[17:29:13.156]                   }
[17:29:13.156]                   ...future.strategy.old <- future::plan("list")
[17:29:13.156]                   options(future.plan = NULL)
[17:29:13.156]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:13.156]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:13.156]                 }
[17:29:13.156]                 ...future.workdir <- getwd()
[17:29:13.156]             }
[17:29:13.156]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:13.156]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:13.156]         }
[17:29:13.156]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:13.156]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:13.156]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:13.156]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:13.156]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:13.156]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:13.156]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:13.156]             base::names(...future.oldOptions))
[17:29:13.156]     }
[17:29:13.156]     if (FALSE) {
[17:29:13.156]     }
[17:29:13.156]     else {
[17:29:13.156]         if (TRUE) {
[17:29:13.156]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:13.156]                 open = "w")
[17:29:13.156]         }
[17:29:13.156]         else {
[17:29:13.156]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:13.156]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:13.156]         }
[17:29:13.156]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:13.156]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:13.156]             base::sink(type = "output", split = FALSE)
[17:29:13.156]             base::close(...future.stdout)
[17:29:13.156]         }, add = TRUE)
[17:29:13.156]     }
[17:29:13.156]     ...future.frame <- base::sys.nframe()
[17:29:13.156]     ...future.conditions <- base::list()
[17:29:13.156]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:13.156]     if (FALSE) {
[17:29:13.156]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:13.156]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:13.156]     }
[17:29:13.156]     ...future.result <- base::tryCatch({
[17:29:13.156]         base::withCallingHandlers({
[17:29:13.156]             ...future.value <- base::withVisible(base::local({
[17:29:13.156]                 ...future.makeSendCondition <- base::local({
[17:29:13.156]                   sendCondition <- NULL
[17:29:13.156]                   function(frame = 1L) {
[17:29:13.156]                     if (is.function(sendCondition)) 
[17:29:13.156]                       return(sendCondition)
[17:29:13.156]                     ns <- getNamespace("parallel")
[17:29:13.156]                     if (exists("sendData", mode = "function", 
[17:29:13.156]                       envir = ns)) {
[17:29:13.156]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:13.156]                         envir = ns)
[17:29:13.156]                       envir <- sys.frame(frame)
[17:29:13.156]                       master <- NULL
[17:29:13.156]                       while (!identical(envir, .GlobalEnv) && 
[17:29:13.156]                         !identical(envir, emptyenv())) {
[17:29:13.156]                         if (exists("master", mode = "list", envir = envir, 
[17:29:13.156]                           inherits = FALSE)) {
[17:29:13.156]                           master <- get("master", mode = "list", 
[17:29:13.156]                             envir = envir, inherits = FALSE)
[17:29:13.156]                           if (inherits(master, c("SOCKnode", 
[17:29:13.156]                             "SOCK0node"))) {
[17:29:13.156]                             sendCondition <<- function(cond) {
[17:29:13.156]                               data <- list(type = "VALUE", value = cond, 
[17:29:13.156]                                 success = TRUE)
[17:29:13.156]                               parallel_sendData(master, data)
[17:29:13.156]                             }
[17:29:13.156]                             return(sendCondition)
[17:29:13.156]                           }
[17:29:13.156]                         }
[17:29:13.156]                         frame <- frame + 1L
[17:29:13.156]                         envir <- sys.frame(frame)
[17:29:13.156]                       }
[17:29:13.156]                     }
[17:29:13.156]                     sendCondition <<- function(cond) NULL
[17:29:13.156]                   }
[17:29:13.156]                 })
[17:29:13.156]                 withCallingHandlers({
[17:29:13.156]                   {
[17:29:13.156]                     Sys.sleep(0.5)
[17:29:13.156]                     list(a = 1, b = 42L)
[17:29:13.156]                   }
[17:29:13.156]                 }, immediateCondition = function(cond) {
[17:29:13.156]                   sendCondition <- ...future.makeSendCondition()
[17:29:13.156]                   sendCondition(cond)
[17:29:13.156]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:13.156]                   {
[17:29:13.156]                     inherits <- base::inherits
[17:29:13.156]                     invokeRestart <- base::invokeRestart
[17:29:13.156]                     is.null <- base::is.null
[17:29:13.156]                     muffled <- FALSE
[17:29:13.156]                     if (inherits(cond, "message")) {
[17:29:13.156]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:13.156]                       if (muffled) 
[17:29:13.156]                         invokeRestart("muffleMessage")
[17:29:13.156]                     }
[17:29:13.156]                     else if (inherits(cond, "warning")) {
[17:29:13.156]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:13.156]                       if (muffled) 
[17:29:13.156]                         invokeRestart("muffleWarning")
[17:29:13.156]                     }
[17:29:13.156]                     else if (inherits(cond, "condition")) {
[17:29:13.156]                       if (!is.null(pattern)) {
[17:29:13.156]                         computeRestarts <- base::computeRestarts
[17:29:13.156]                         grepl <- base::grepl
[17:29:13.156]                         restarts <- computeRestarts(cond)
[17:29:13.156]                         for (restart in restarts) {
[17:29:13.156]                           name <- restart$name
[17:29:13.156]                           if (is.null(name)) 
[17:29:13.156]                             next
[17:29:13.156]                           if (!grepl(pattern, name)) 
[17:29:13.156]                             next
[17:29:13.156]                           invokeRestart(restart)
[17:29:13.156]                           muffled <- TRUE
[17:29:13.156]                           break
[17:29:13.156]                         }
[17:29:13.156]                       }
[17:29:13.156]                     }
[17:29:13.156]                     invisible(muffled)
[17:29:13.156]                   }
[17:29:13.156]                   muffleCondition(cond)
[17:29:13.156]                 })
[17:29:13.156]             }))
[17:29:13.156]             future::FutureResult(value = ...future.value$value, 
[17:29:13.156]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:13.156]                   ...future.rng), globalenv = if (FALSE) 
[17:29:13.156]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:13.156]                     ...future.globalenv.names))
[17:29:13.156]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:13.156]         }, condition = base::local({
[17:29:13.156]             c <- base::c
[17:29:13.156]             inherits <- base::inherits
[17:29:13.156]             invokeRestart <- base::invokeRestart
[17:29:13.156]             length <- base::length
[17:29:13.156]             list <- base::list
[17:29:13.156]             seq.int <- base::seq.int
[17:29:13.156]             signalCondition <- base::signalCondition
[17:29:13.156]             sys.calls <- base::sys.calls
[17:29:13.156]             `[[` <- base::`[[`
[17:29:13.156]             `+` <- base::`+`
[17:29:13.156]             `<<-` <- base::`<<-`
[17:29:13.156]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:13.156]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:13.156]                   3L)]
[17:29:13.156]             }
[17:29:13.156]             function(cond) {
[17:29:13.156]                 is_error <- inherits(cond, "error")
[17:29:13.156]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:13.156]                   NULL)
[17:29:13.156]                 if (is_error) {
[17:29:13.156]                   sessionInformation <- function() {
[17:29:13.156]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:13.156]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:13.156]                       search = base::search(), system = base::Sys.info())
[17:29:13.156]                   }
[17:29:13.156]                   ...future.conditions[[length(...future.conditions) + 
[17:29:13.156]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:13.156]                     cond$call), session = sessionInformation(), 
[17:29:13.156]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:13.156]                   signalCondition(cond)
[17:29:13.156]                 }
[17:29:13.156]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:13.156]                 "immediateCondition"))) {
[17:29:13.156]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:13.156]                   ...future.conditions[[length(...future.conditions) + 
[17:29:13.156]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:13.156]                   if (TRUE && !signal) {
[17:29:13.156]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:13.156]                     {
[17:29:13.156]                       inherits <- base::inherits
[17:29:13.156]                       invokeRestart <- base::invokeRestart
[17:29:13.156]                       is.null <- base::is.null
[17:29:13.156]                       muffled <- FALSE
[17:29:13.156]                       if (inherits(cond, "message")) {
[17:29:13.156]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:13.156]                         if (muffled) 
[17:29:13.156]                           invokeRestart("muffleMessage")
[17:29:13.156]                       }
[17:29:13.156]                       else if (inherits(cond, "warning")) {
[17:29:13.156]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:13.156]                         if (muffled) 
[17:29:13.156]                           invokeRestart("muffleWarning")
[17:29:13.156]                       }
[17:29:13.156]                       else if (inherits(cond, "condition")) {
[17:29:13.156]                         if (!is.null(pattern)) {
[17:29:13.156]                           computeRestarts <- base::computeRestarts
[17:29:13.156]                           grepl <- base::grepl
[17:29:13.156]                           restarts <- computeRestarts(cond)
[17:29:13.156]                           for (restart in restarts) {
[17:29:13.156]                             name <- restart$name
[17:29:13.156]                             if (is.null(name)) 
[17:29:13.156]                               next
[17:29:13.156]                             if (!grepl(pattern, name)) 
[17:29:13.156]                               next
[17:29:13.156]                             invokeRestart(restart)
[17:29:13.156]                             muffled <- TRUE
[17:29:13.156]                             break
[17:29:13.156]                           }
[17:29:13.156]                         }
[17:29:13.156]                       }
[17:29:13.156]                       invisible(muffled)
[17:29:13.156]                     }
[17:29:13.156]                     muffleCondition(cond, pattern = "^muffle")
[17:29:13.156]                   }
[17:29:13.156]                 }
[17:29:13.156]                 else {
[17:29:13.156]                   if (TRUE) {
[17:29:13.156]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:13.156]                     {
[17:29:13.156]                       inherits <- base::inherits
[17:29:13.156]                       invokeRestart <- base::invokeRestart
[17:29:13.156]                       is.null <- base::is.null
[17:29:13.156]                       muffled <- FALSE
[17:29:13.156]                       if (inherits(cond, "message")) {
[17:29:13.156]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:13.156]                         if (muffled) 
[17:29:13.156]                           invokeRestart("muffleMessage")
[17:29:13.156]                       }
[17:29:13.156]                       else if (inherits(cond, "warning")) {
[17:29:13.156]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:13.156]                         if (muffled) 
[17:29:13.156]                           invokeRestart("muffleWarning")
[17:29:13.156]                       }
[17:29:13.156]                       else if (inherits(cond, "condition")) {
[17:29:13.156]                         if (!is.null(pattern)) {
[17:29:13.156]                           computeRestarts <- base::computeRestarts
[17:29:13.156]                           grepl <- base::grepl
[17:29:13.156]                           restarts <- computeRestarts(cond)
[17:29:13.156]                           for (restart in restarts) {
[17:29:13.156]                             name <- restart$name
[17:29:13.156]                             if (is.null(name)) 
[17:29:13.156]                               next
[17:29:13.156]                             if (!grepl(pattern, name)) 
[17:29:13.156]                               next
[17:29:13.156]                             invokeRestart(restart)
[17:29:13.156]                             muffled <- TRUE
[17:29:13.156]                             break
[17:29:13.156]                           }
[17:29:13.156]                         }
[17:29:13.156]                       }
[17:29:13.156]                       invisible(muffled)
[17:29:13.156]                     }
[17:29:13.156]                     muffleCondition(cond, pattern = "^muffle")
[17:29:13.156]                   }
[17:29:13.156]                 }
[17:29:13.156]             }
[17:29:13.156]         }))
[17:29:13.156]     }, error = function(ex) {
[17:29:13.156]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:13.156]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:13.156]                 ...future.rng), started = ...future.startTime, 
[17:29:13.156]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:13.156]             version = "1.8"), class = "FutureResult")
[17:29:13.156]     }, finally = {
[17:29:13.156]         if (!identical(...future.workdir, getwd())) 
[17:29:13.156]             setwd(...future.workdir)
[17:29:13.156]         {
[17:29:13.156]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:13.156]                 ...future.oldOptions$nwarnings <- NULL
[17:29:13.156]             }
[17:29:13.156]             base::options(...future.oldOptions)
[17:29:13.156]             if (.Platform$OS.type == "windows") {
[17:29:13.156]                 old_names <- names(...future.oldEnvVars)
[17:29:13.156]                 envs <- base::Sys.getenv()
[17:29:13.156]                 names <- names(envs)
[17:29:13.156]                 common <- intersect(names, old_names)
[17:29:13.156]                 added <- setdiff(names, old_names)
[17:29:13.156]                 removed <- setdiff(old_names, names)
[17:29:13.156]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:13.156]                   envs[common]]
[17:29:13.156]                 NAMES <- toupper(changed)
[17:29:13.156]                 args <- list()
[17:29:13.156]                 for (kk in seq_along(NAMES)) {
[17:29:13.156]                   name <- changed[[kk]]
[17:29:13.156]                   NAME <- NAMES[[kk]]
[17:29:13.156]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:13.156]                     next
[17:29:13.156]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:13.156]                 }
[17:29:13.156]                 NAMES <- toupper(added)
[17:29:13.156]                 for (kk in seq_along(NAMES)) {
[17:29:13.156]                   name <- added[[kk]]
[17:29:13.156]                   NAME <- NAMES[[kk]]
[17:29:13.156]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:13.156]                     next
[17:29:13.156]                   args[[name]] <- ""
[17:29:13.156]                 }
[17:29:13.156]                 NAMES <- toupper(removed)
[17:29:13.156]                 for (kk in seq_along(NAMES)) {
[17:29:13.156]                   name <- removed[[kk]]
[17:29:13.156]                   NAME <- NAMES[[kk]]
[17:29:13.156]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:13.156]                     next
[17:29:13.156]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:13.156]                 }
[17:29:13.156]                 if (length(args) > 0) 
[17:29:13.156]                   base::do.call(base::Sys.setenv, args = args)
[17:29:13.156]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:13.156]             }
[17:29:13.156]             else {
[17:29:13.156]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:13.156]             }
[17:29:13.156]             {
[17:29:13.156]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:13.156]                   0L) {
[17:29:13.156]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:13.156]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:13.156]                   base::options(opts)
[17:29:13.156]                 }
[17:29:13.156]                 {
[17:29:13.156]                   {
[17:29:13.156]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:13.156]                     NULL
[17:29:13.156]                   }
[17:29:13.156]                   options(future.plan = NULL)
[17:29:13.156]                   if (is.na(NA_character_)) 
[17:29:13.156]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:13.156]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:13.156]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:13.156]                     .init = FALSE)
[17:29:13.156]                 }
[17:29:13.156]             }
[17:29:13.156]         }
[17:29:13.156]     })
[17:29:13.156]     if (TRUE) {
[17:29:13.156]         base::sink(type = "output", split = FALSE)
[17:29:13.156]         if (TRUE) {
[17:29:13.156]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:13.156]         }
[17:29:13.156]         else {
[17:29:13.156]             ...future.result["stdout"] <- base::list(NULL)
[17:29:13.156]         }
[17:29:13.156]         base::close(...future.stdout)
[17:29:13.156]         ...future.stdout <- NULL
[17:29:13.156]     }
[17:29:13.156]     ...future.result$conditions <- ...future.conditions
[17:29:13.156]     ...future.result$finished <- base::Sys.time()
[17:29:13.156]     ...future.result
[17:29:13.156] }
[17:29:13.164] MultisessionFuture started
[17:29:13.165] - Launch lazy future ... done
[17:29:13.165] run() for 'MultisessionFuture' ... done
[17:29:13.705] receiveMessageFromWorker() for ClusterFuture ...
[17:29:13.706] - Validating connection of MultisessionFuture
[17:29:13.706] - received message: FutureResult
[17:29:13.707] - Received FutureResult
[17:29:13.707] - Erased future from FutureRegistry
[17:29:13.707] result() for ClusterFuture ...
[17:29:13.708] - result already collected: FutureResult
[17:29:13.708] result() for ClusterFuture ... done
[17:29:13.708] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:13.709] A MultisessionFuture was resolved (result was not collected)
[17:29:13.709] getGlobalsAndPackages() ...
[17:29:13.709] Searching for globals...
[17:29:13.712] - globals found: [3] '{', 'Sys.sleep', 'list'
[17:29:13.712] Searching for globals ... DONE
[17:29:13.712] Resolving globals: FALSE
[17:29:13.713] 
[17:29:13.713] 
[17:29:13.713] getGlobalsAndPackages() ... DONE
[17:29:13.714] run() for 'Future' ...
[17:29:13.714] - state: 'created'
[17:29:13.714] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:13.734] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:13.734] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:13.735]   - Field: 'node'
[17:29:13.735]   - Field: 'label'
[17:29:13.735]   - Field: 'local'
[17:29:13.735]   - Field: 'owner'
[17:29:13.735]   - Field: 'envir'
[17:29:13.736]   - Field: 'workers'
[17:29:13.736]   - Field: 'packages'
[17:29:13.736]   - Field: 'gc'
[17:29:13.736]   - Field: 'conditions'
[17:29:13.736]   - Field: 'persistent'
[17:29:13.737]   - Field: 'expr'
[17:29:13.737]   - Field: 'uuid'
[17:29:13.737]   - Field: 'seed'
[17:29:13.738]   - Field: 'version'
[17:29:13.738]   - Field: 'result'
[17:29:13.738]   - Field: 'asynchronous'
[17:29:13.738]   - Field: 'calls'
[17:29:13.739]   - Field: 'globals'
[17:29:13.739]   - Field: 'stdout'
[17:29:13.739]   - Field: 'earlySignal'
[17:29:13.740]   - Field: 'lazy'
[17:29:13.740]   - Field: 'state'
[17:29:13.740] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:13.740] - Launch lazy future ...
[17:29:13.741] Packages needed by the future expression (n = 0): <none>
[17:29:13.741] Packages needed by future strategies (n = 0): <none>
[17:29:13.742] {
[17:29:13.742]     {
[17:29:13.742]         {
[17:29:13.742]             ...future.startTime <- base::Sys.time()
[17:29:13.742]             {
[17:29:13.742]                 {
[17:29:13.742]                   {
[17:29:13.742]                     {
[17:29:13.742]                       base::local({
[17:29:13.742]                         has_future <- base::requireNamespace("future", 
[17:29:13.742]                           quietly = TRUE)
[17:29:13.742]                         if (has_future) {
[17:29:13.742]                           ns <- base::getNamespace("future")
[17:29:13.742]                           version <- ns[[".package"]][["version"]]
[17:29:13.742]                           if (is.null(version)) 
[17:29:13.742]                             version <- utils::packageVersion("future")
[17:29:13.742]                         }
[17:29:13.742]                         else {
[17:29:13.742]                           version <- NULL
[17:29:13.742]                         }
[17:29:13.742]                         if (!has_future || version < "1.8.0") {
[17:29:13.742]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:13.742]                             "", base::R.version$version.string), 
[17:29:13.742]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:13.742]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:13.742]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:13.742]                               "release", "version")], collapse = " "), 
[17:29:13.742]                             hostname = base::Sys.info()[["nodename"]])
[17:29:13.742]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:13.742]                             info)
[17:29:13.742]                           info <- base::paste(info, collapse = "; ")
[17:29:13.742]                           if (!has_future) {
[17:29:13.742]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:13.742]                               info)
[17:29:13.742]                           }
[17:29:13.742]                           else {
[17:29:13.742]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:13.742]                               info, version)
[17:29:13.742]                           }
[17:29:13.742]                           base::stop(msg)
[17:29:13.742]                         }
[17:29:13.742]                       })
[17:29:13.742]                     }
[17:29:13.742]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:13.742]                     base::options(mc.cores = 1L)
[17:29:13.742]                   }
[17:29:13.742]                   ...future.strategy.old <- future::plan("list")
[17:29:13.742]                   options(future.plan = NULL)
[17:29:13.742]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:13.742]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:13.742]                 }
[17:29:13.742]                 ...future.workdir <- getwd()
[17:29:13.742]             }
[17:29:13.742]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:13.742]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:13.742]         }
[17:29:13.742]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:13.742]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:13.742]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:13.742]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:13.742]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:13.742]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:13.742]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:13.742]             base::names(...future.oldOptions))
[17:29:13.742]     }
[17:29:13.742]     if (FALSE) {
[17:29:13.742]     }
[17:29:13.742]     else {
[17:29:13.742]         if (TRUE) {
[17:29:13.742]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:13.742]                 open = "w")
[17:29:13.742]         }
[17:29:13.742]         else {
[17:29:13.742]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:13.742]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:13.742]         }
[17:29:13.742]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:13.742]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:13.742]             base::sink(type = "output", split = FALSE)
[17:29:13.742]             base::close(...future.stdout)
[17:29:13.742]         }, add = TRUE)
[17:29:13.742]     }
[17:29:13.742]     ...future.frame <- base::sys.nframe()
[17:29:13.742]     ...future.conditions <- base::list()
[17:29:13.742]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:13.742]     if (FALSE) {
[17:29:13.742]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:13.742]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:13.742]     }
[17:29:13.742]     ...future.result <- base::tryCatch({
[17:29:13.742]         base::withCallingHandlers({
[17:29:13.742]             ...future.value <- base::withVisible(base::local({
[17:29:13.742]                 ...future.makeSendCondition <- base::local({
[17:29:13.742]                   sendCondition <- NULL
[17:29:13.742]                   function(frame = 1L) {
[17:29:13.742]                     if (is.function(sendCondition)) 
[17:29:13.742]                       return(sendCondition)
[17:29:13.742]                     ns <- getNamespace("parallel")
[17:29:13.742]                     if (exists("sendData", mode = "function", 
[17:29:13.742]                       envir = ns)) {
[17:29:13.742]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:13.742]                         envir = ns)
[17:29:13.742]                       envir <- sys.frame(frame)
[17:29:13.742]                       master <- NULL
[17:29:13.742]                       while (!identical(envir, .GlobalEnv) && 
[17:29:13.742]                         !identical(envir, emptyenv())) {
[17:29:13.742]                         if (exists("master", mode = "list", envir = envir, 
[17:29:13.742]                           inherits = FALSE)) {
[17:29:13.742]                           master <- get("master", mode = "list", 
[17:29:13.742]                             envir = envir, inherits = FALSE)
[17:29:13.742]                           if (inherits(master, c("SOCKnode", 
[17:29:13.742]                             "SOCK0node"))) {
[17:29:13.742]                             sendCondition <<- function(cond) {
[17:29:13.742]                               data <- list(type = "VALUE", value = cond, 
[17:29:13.742]                                 success = TRUE)
[17:29:13.742]                               parallel_sendData(master, data)
[17:29:13.742]                             }
[17:29:13.742]                             return(sendCondition)
[17:29:13.742]                           }
[17:29:13.742]                         }
[17:29:13.742]                         frame <- frame + 1L
[17:29:13.742]                         envir <- sys.frame(frame)
[17:29:13.742]                       }
[17:29:13.742]                     }
[17:29:13.742]                     sendCondition <<- function(cond) NULL
[17:29:13.742]                   }
[17:29:13.742]                 })
[17:29:13.742]                 withCallingHandlers({
[17:29:13.742]                   {
[17:29:13.742]                     Sys.sleep(0.5)
[17:29:13.742]                     list(a = 1, b = 42L)
[17:29:13.742]                   }
[17:29:13.742]                 }, immediateCondition = function(cond) {
[17:29:13.742]                   sendCondition <- ...future.makeSendCondition()
[17:29:13.742]                   sendCondition(cond)
[17:29:13.742]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:13.742]                   {
[17:29:13.742]                     inherits <- base::inherits
[17:29:13.742]                     invokeRestart <- base::invokeRestart
[17:29:13.742]                     is.null <- base::is.null
[17:29:13.742]                     muffled <- FALSE
[17:29:13.742]                     if (inherits(cond, "message")) {
[17:29:13.742]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:13.742]                       if (muffled) 
[17:29:13.742]                         invokeRestart("muffleMessage")
[17:29:13.742]                     }
[17:29:13.742]                     else if (inherits(cond, "warning")) {
[17:29:13.742]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:13.742]                       if (muffled) 
[17:29:13.742]                         invokeRestart("muffleWarning")
[17:29:13.742]                     }
[17:29:13.742]                     else if (inherits(cond, "condition")) {
[17:29:13.742]                       if (!is.null(pattern)) {
[17:29:13.742]                         computeRestarts <- base::computeRestarts
[17:29:13.742]                         grepl <- base::grepl
[17:29:13.742]                         restarts <- computeRestarts(cond)
[17:29:13.742]                         for (restart in restarts) {
[17:29:13.742]                           name <- restart$name
[17:29:13.742]                           if (is.null(name)) 
[17:29:13.742]                             next
[17:29:13.742]                           if (!grepl(pattern, name)) 
[17:29:13.742]                             next
[17:29:13.742]                           invokeRestart(restart)
[17:29:13.742]                           muffled <- TRUE
[17:29:13.742]                           break
[17:29:13.742]                         }
[17:29:13.742]                       }
[17:29:13.742]                     }
[17:29:13.742]                     invisible(muffled)
[17:29:13.742]                   }
[17:29:13.742]                   muffleCondition(cond)
[17:29:13.742]                 })
[17:29:13.742]             }))
[17:29:13.742]             future::FutureResult(value = ...future.value$value, 
[17:29:13.742]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:13.742]                   ...future.rng), globalenv = if (FALSE) 
[17:29:13.742]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:13.742]                     ...future.globalenv.names))
[17:29:13.742]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:13.742]         }, condition = base::local({
[17:29:13.742]             c <- base::c
[17:29:13.742]             inherits <- base::inherits
[17:29:13.742]             invokeRestart <- base::invokeRestart
[17:29:13.742]             length <- base::length
[17:29:13.742]             list <- base::list
[17:29:13.742]             seq.int <- base::seq.int
[17:29:13.742]             signalCondition <- base::signalCondition
[17:29:13.742]             sys.calls <- base::sys.calls
[17:29:13.742]             `[[` <- base::`[[`
[17:29:13.742]             `+` <- base::`+`
[17:29:13.742]             `<<-` <- base::`<<-`
[17:29:13.742]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:13.742]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:13.742]                   3L)]
[17:29:13.742]             }
[17:29:13.742]             function(cond) {
[17:29:13.742]                 is_error <- inherits(cond, "error")
[17:29:13.742]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:13.742]                   NULL)
[17:29:13.742]                 if (is_error) {
[17:29:13.742]                   sessionInformation <- function() {
[17:29:13.742]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:13.742]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:13.742]                       search = base::search(), system = base::Sys.info())
[17:29:13.742]                   }
[17:29:13.742]                   ...future.conditions[[length(...future.conditions) + 
[17:29:13.742]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:13.742]                     cond$call), session = sessionInformation(), 
[17:29:13.742]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:13.742]                   signalCondition(cond)
[17:29:13.742]                 }
[17:29:13.742]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:13.742]                 "immediateCondition"))) {
[17:29:13.742]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:13.742]                   ...future.conditions[[length(...future.conditions) + 
[17:29:13.742]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:13.742]                   if (TRUE && !signal) {
[17:29:13.742]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:13.742]                     {
[17:29:13.742]                       inherits <- base::inherits
[17:29:13.742]                       invokeRestart <- base::invokeRestart
[17:29:13.742]                       is.null <- base::is.null
[17:29:13.742]                       muffled <- FALSE
[17:29:13.742]                       if (inherits(cond, "message")) {
[17:29:13.742]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:13.742]                         if (muffled) 
[17:29:13.742]                           invokeRestart("muffleMessage")
[17:29:13.742]                       }
[17:29:13.742]                       else if (inherits(cond, "warning")) {
[17:29:13.742]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:13.742]                         if (muffled) 
[17:29:13.742]                           invokeRestart("muffleWarning")
[17:29:13.742]                       }
[17:29:13.742]                       else if (inherits(cond, "condition")) {
[17:29:13.742]                         if (!is.null(pattern)) {
[17:29:13.742]                           computeRestarts <- base::computeRestarts
[17:29:13.742]                           grepl <- base::grepl
[17:29:13.742]                           restarts <- computeRestarts(cond)
[17:29:13.742]                           for (restart in restarts) {
[17:29:13.742]                             name <- restart$name
[17:29:13.742]                             if (is.null(name)) 
[17:29:13.742]                               next
[17:29:13.742]                             if (!grepl(pattern, name)) 
[17:29:13.742]                               next
[17:29:13.742]                             invokeRestart(restart)
[17:29:13.742]                             muffled <- TRUE
[17:29:13.742]                             break
[17:29:13.742]                           }
[17:29:13.742]                         }
[17:29:13.742]                       }
[17:29:13.742]                       invisible(muffled)
[17:29:13.742]                     }
[17:29:13.742]                     muffleCondition(cond, pattern = "^muffle")
[17:29:13.742]                   }
[17:29:13.742]                 }
[17:29:13.742]                 else {
[17:29:13.742]                   if (TRUE) {
[17:29:13.742]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:13.742]                     {
[17:29:13.742]                       inherits <- base::inherits
[17:29:13.742]                       invokeRestart <- base::invokeRestart
[17:29:13.742]                       is.null <- base::is.null
[17:29:13.742]                       muffled <- FALSE
[17:29:13.742]                       if (inherits(cond, "message")) {
[17:29:13.742]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:13.742]                         if (muffled) 
[17:29:13.742]                           invokeRestart("muffleMessage")
[17:29:13.742]                       }
[17:29:13.742]                       else if (inherits(cond, "warning")) {
[17:29:13.742]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:13.742]                         if (muffled) 
[17:29:13.742]                           invokeRestart("muffleWarning")
[17:29:13.742]                       }
[17:29:13.742]                       else if (inherits(cond, "condition")) {
[17:29:13.742]                         if (!is.null(pattern)) {
[17:29:13.742]                           computeRestarts <- base::computeRestarts
[17:29:13.742]                           grepl <- base::grepl
[17:29:13.742]                           restarts <- computeRestarts(cond)
[17:29:13.742]                           for (restart in restarts) {
[17:29:13.742]                             name <- restart$name
[17:29:13.742]                             if (is.null(name)) 
[17:29:13.742]                               next
[17:29:13.742]                             if (!grepl(pattern, name)) 
[17:29:13.742]                               next
[17:29:13.742]                             invokeRestart(restart)
[17:29:13.742]                             muffled <- TRUE
[17:29:13.742]                             break
[17:29:13.742]                           }
[17:29:13.742]                         }
[17:29:13.742]                       }
[17:29:13.742]                       invisible(muffled)
[17:29:13.742]                     }
[17:29:13.742]                     muffleCondition(cond, pattern = "^muffle")
[17:29:13.742]                   }
[17:29:13.742]                 }
[17:29:13.742]             }
[17:29:13.742]         }))
[17:29:13.742]     }, error = function(ex) {
[17:29:13.742]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:13.742]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:13.742]                 ...future.rng), started = ...future.startTime, 
[17:29:13.742]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:13.742]             version = "1.8"), class = "FutureResult")
[17:29:13.742]     }, finally = {
[17:29:13.742]         if (!identical(...future.workdir, getwd())) 
[17:29:13.742]             setwd(...future.workdir)
[17:29:13.742]         {
[17:29:13.742]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:13.742]                 ...future.oldOptions$nwarnings <- NULL
[17:29:13.742]             }
[17:29:13.742]             base::options(...future.oldOptions)
[17:29:13.742]             if (.Platform$OS.type == "windows") {
[17:29:13.742]                 old_names <- names(...future.oldEnvVars)
[17:29:13.742]                 envs <- base::Sys.getenv()
[17:29:13.742]                 names <- names(envs)
[17:29:13.742]                 common <- intersect(names, old_names)
[17:29:13.742]                 added <- setdiff(names, old_names)
[17:29:13.742]                 removed <- setdiff(old_names, names)
[17:29:13.742]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:13.742]                   envs[common]]
[17:29:13.742]                 NAMES <- toupper(changed)
[17:29:13.742]                 args <- list()
[17:29:13.742]                 for (kk in seq_along(NAMES)) {
[17:29:13.742]                   name <- changed[[kk]]
[17:29:13.742]                   NAME <- NAMES[[kk]]
[17:29:13.742]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:13.742]                     next
[17:29:13.742]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:13.742]                 }
[17:29:13.742]                 NAMES <- toupper(added)
[17:29:13.742]                 for (kk in seq_along(NAMES)) {
[17:29:13.742]                   name <- added[[kk]]
[17:29:13.742]                   NAME <- NAMES[[kk]]
[17:29:13.742]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:13.742]                     next
[17:29:13.742]                   args[[name]] <- ""
[17:29:13.742]                 }
[17:29:13.742]                 NAMES <- toupper(removed)
[17:29:13.742]                 for (kk in seq_along(NAMES)) {
[17:29:13.742]                   name <- removed[[kk]]
[17:29:13.742]                   NAME <- NAMES[[kk]]
[17:29:13.742]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:13.742]                     next
[17:29:13.742]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:13.742]                 }
[17:29:13.742]                 if (length(args) > 0) 
[17:29:13.742]                   base::do.call(base::Sys.setenv, args = args)
[17:29:13.742]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:13.742]             }
[17:29:13.742]             else {
[17:29:13.742]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:13.742]             }
[17:29:13.742]             {
[17:29:13.742]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:13.742]                   0L) {
[17:29:13.742]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:13.742]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:13.742]                   base::options(opts)
[17:29:13.742]                 }
[17:29:13.742]                 {
[17:29:13.742]                   {
[17:29:13.742]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:13.742]                     NULL
[17:29:13.742]                   }
[17:29:13.742]                   options(future.plan = NULL)
[17:29:13.742]                   if (is.na(NA_character_)) 
[17:29:13.742]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:13.742]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:13.742]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:13.742]                     .init = FALSE)
[17:29:13.742]                 }
[17:29:13.742]             }
[17:29:13.742]         }
[17:29:13.742]     })
[17:29:13.742]     if (TRUE) {
[17:29:13.742]         base::sink(type = "output", split = FALSE)
[17:29:13.742]         if (TRUE) {
[17:29:13.742]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:13.742]         }
[17:29:13.742]         else {
[17:29:13.742]             ...future.result["stdout"] <- base::list(NULL)
[17:29:13.742]         }
[17:29:13.742]         base::close(...future.stdout)
[17:29:13.742]         ...future.stdout <- NULL
[17:29:13.742]     }
[17:29:13.742]     ...future.result$conditions <- ...future.conditions
[17:29:13.742]     ...future.result$finished <- base::Sys.time()
[17:29:13.742]     ...future.result
[17:29:13.742] }
[17:29:13.752] MultisessionFuture started
[17:29:13.752] - Launch lazy future ... done
[17:29:13.753] run() for 'MultisessionFuture' ... done
[17:29:14.288] receiveMessageFromWorker() for ClusterFuture ...
[17:29:14.288] - Validating connection of MultisessionFuture
[17:29:14.289] - received message: FutureResult
[17:29:14.289] - Received FutureResult
[17:29:14.289] - Erased future from FutureRegistry
[17:29:14.289] result() for ClusterFuture ...
[17:29:14.290] - result already collected: FutureResult
[17:29:14.290] result() for ClusterFuture ... done
[17:29:14.290] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:14.290] A MultisessionFuture was resolved (result was not collected)
- w/ exception ...
[17:29:14.290] getGlobalsAndPackages() ...
[17:29:14.290] Searching for globals...
[17:29:14.291] - globals found: [2] 'list', 'stop'
[17:29:14.292] Searching for globals ... DONE
[17:29:14.292] Resolving globals: FALSE
[17:29:14.292] 
[17:29:14.293] 
[17:29:14.293] getGlobalsAndPackages() ... DONE
[17:29:14.293] run() for 'Future' ...
[17:29:14.294] - state: 'created'
[17:29:14.294] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:14.311] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:14.311] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:14.311]   - Field: 'node'
[17:29:14.312]   - Field: 'label'
[17:29:14.312]   - Field: 'local'
[17:29:14.312]   - Field: 'owner'
[17:29:14.312]   - Field: 'envir'
[17:29:14.313]   - Field: 'workers'
[17:29:14.313]   - Field: 'packages'
[17:29:14.313]   - Field: 'gc'
[17:29:14.313]   - Field: 'conditions'
[17:29:14.314]   - Field: 'persistent'
[17:29:14.314]   - Field: 'expr'
[17:29:14.314]   - Field: 'uuid'
[17:29:14.314]   - Field: 'seed'
[17:29:14.315]   - Field: 'version'
[17:29:14.315]   - Field: 'result'
[17:29:14.315]   - Field: 'asynchronous'
[17:29:14.315]   - Field: 'calls'
[17:29:14.316]   - Field: 'globals'
[17:29:14.316]   - Field: 'stdout'
[17:29:14.316]   - Field: 'earlySignal'
[17:29:14.317]   - Field: 'lazy'
[17:29:14.317]   - Field: 'state'
[17:29:14.317] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:14.318] - Launch lazy future ...
[17:29:14.318] Packages needed by the future expression (n = 0): <none>
[17:29:14.319] Packages needed by future strategies (n = 0): <none>
[17:29:14.320] {
[17:29:14.320]     {
[17:29:14.320]         {
[17:29:14.320]             ...future.startTime <- base::Sys.time()
[17:29:14.320]             {
[17:29:14.320]                 {
[17:29:14.320]                   {
[17:29:14.320]                     {
[17:29:14.320]                       base::local({
[17:29:14.320]                         has_future <- base::requireNamespace("future", 
[17:29:14.320]                           quietly = TRUE)
[17:29:14.320]                         if (has_future) {
[17:29:14.320]                           ns <- base::getNamespace("future")
[17:29:14.320]                           version <- ns[[".package"]][["version"]]
[17:29:14.320]                           if (is.null(version)) 
[17:29:14.320]                             version <- utils::packageVersion("future")
[17:29:14.320]                         }
[17:29:14.320]                         else {
[17:29:14.320]                           version <- NULL
[17:29:14.320]                         }
[17:29:14.320]                         if (!has_future || version < "1.8.0") {
[17:29:14.320]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:14.320]                             "", base::R.version$version.string), 
[17:29:14.320]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:14.320]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:14.320]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:14.320]                               "release", "version")], collapse = " "), 
[17:29:14.320]                             hostname = base::Sys.info()[["nodename"]])
[17:29:14.320]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:14.320]                             info)
[17:29:14.320]                           info <- base::paste(info, collapse = "; ")
[17:29:14.320]                           if (!has_future) {
[17:29:14.320]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:14.320]                               info)
[17:29:14.320]                           }
[17:29:14.320]                           else {
[17:29:14.320]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:14.320]                               info, version)
[17:29:14.320]                           }
[17:29:14.320]                           base::stop(msg)
[17:29:14.320]                         }
[17:29:14.320]                       })
[17:29:14.320]                     }
[17:29:14.320]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:14.320]                     base::options(mc.cores = 1L)
[17:29:14.320]                   }
[17:29:14.320]                   ...future.strategy.old <- future::plan("list")
[17:29:14.320]                   options(future.plan = NULL)
[17:29:14.320]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:14.320]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:14.320]                 }
[17:29:14.320]                 ...future.workdir <- getwd()
[17:29:14.320]             }
[17:29:14.320]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:14.320]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:14.320]         }
[17:29:14.320]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:14.320]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:14.320]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:14.320]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:14.320]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:14.320]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:14.320]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:14.320]             base::names(...future.oldOptions))
[17:29:14.320]     }
[17:29:14.320]     if (FALSE) {
[17:29:14.320]     }
[17:29:14.320]     else {
[17:29:14.320]         if (TRUE) {
[17:29:14.320]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:14.320]                 open = "w")
[17:29:14.320]         }
[17:29:14.320]         else {
[17:29:14.320]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:14.320]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:14.320]         }
[17:29:14.320]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:14.320]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:14.320]             base::sink(type = "output", split = FALSE)
[17:29:14.320]             base::close(...future.stdout)
[17:29:14.320]         }, add = TRUE)
[17:29:14.320]     }
[17:29:14.320]     ...future.frame <- base::sys.nframe()
[17:29:14.320]     ...future.conditions <- base::list()
[17:29:14.320]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:14.320]     if (FALSE) {
[17:29:14.320]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:14.320]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:14.320]     }
[17:29:14.320]     ...future.result <- base::tryCatch({
[17:29:14.320]         base::withCallingHandlers({
[17:29:14.320]             ...future.value <- base::withVisible(base::local({
[17:29:14.320]                 ...future.makeSendCondition <- base::local({
[17:29:14.320]                   sendCondition <- NULL
[17:29:14.320]                   function(frame = 1L) {
[17:29:14.320]                     if (is.function(sendCondition)) 
[17:29:14.320]                       return(sendCondition)
[17:29:14.320]                     ns <- getNamespace("parallel")
[17:29:14.320]                     if (exists("sendData", mode = "function", 
[17:29:14.320]                       envir = ns)) {
[17:29:14.320]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:14.320]                         envir = ns)
[17:29:14.320]                       envir <- sys.frame(frame)
[17:29:14.320]                       master <- NULL
[17:29:14.320]                       while (!identical(envir, .GlobalEnv) && 
[17:29:14.320]                         !identical(envir, emptyenv())) {
[17:29:14.320]                         if (exists("master", mode = "list", envir = envir, 
[17:29:14.320]                           inherits = FALSE)) {
[17:29:14.320]                           master <- get("master", mode = "list", 
[17:29:14.320]                             envir = envir, inherits = FALSE)
[17:29:14.320]                           if (inherits(master, c("SOCKnode", 
[17:29:14.320]                             "SOCK0node"))) {
[17:29:14.320]                             sendCondition <<- function(cond) {
[17:29:14.320]                               data <- list(type = "VALUE", value = cond, 
[17:29:14.320]                                 success = TRUE)
[17:29:14.320]                               parallel_sendData(master, data)
[17:29:14.320]                             }
[17:29:14.320]                             return(sendCondition)
[17:29:14.320]                           }
[17:29:14.320]                         }
[17:29:14.320]                         frame <- frame + 1L
[17:29:14.320]                         envir <- sys.frame(frame)
[17:29:14.320]                       }
[17:29:14.320]                     }
[17:29:14.320]                     sendCondition <<- function(cond) NULL
[17:29:14.320]                   }
[17:29:14.320]                 })
[17:29:14.320]                 withCallingHandlers({
[17:29:14.320]                   list(a = 1, b = 42L, c = stop("Nah!"))
[17:29:14.320]                 }, immediateCondition = function(cond) {
[17:29:14.320]                   sendCondition <- ...future.makeSendCondition()
[17:29:14.320]                   sendCondition(cond)
[17:29:14.320]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:14.320]                   {
[17:29:14.320]                     inherits <- base::inherits
[17:29:14.320]                     invokeRestart <- base::invokeRestart
[17:29:14.320]                     is.null <- base::is.null
[17:29:14.320]                     muffled <- FALSE
[17:29:14.320]                     if (inherits(cond, "message")) {
[17:29:14.320]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:14.320]                       if (muffled) 
[17:29:14.320]                         invokeRestart("muffleMessage")
[17:29:14.320]                     }
[17:29:14.320]                     else if (inherits(cond, "warning")) {
[17:29:14.320]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:14.320]                       if (muffled) 
[17:29:14.320]                         invokeRestart("muffleWarning")
[17:29:14.320]                     }
[17:29:14.320]                     else if (inherits(cond, "condition")) {
[17:29:14.320]                       if (!is.null(pattern)) {
[17:29:14.320]                         computeRestarts <- base::computeRestarts
[17:29:14.320]                         grepl <- base::grepl
[17:29:14.320]                         restarts <- computeRestarts(cond)
[17:29:14.320]                         for (restart in restarts) {
[17:29:14.320]                           name <- restart$name
[17:29:14.320]                           if (is.null(name)) 
[17:29:14.320]                             next
[17:29:14.320]                           if (!grepl(pattern, name)) 
[17:29:14.320]                             next
[17:29:14.320]                           invokeRestart(restart)
[17:29:14.320]                           muffled <- TRUE
[17:29:14.320]                           break
[17:29:14.320]                         }
[17:29:14.320]                       }
[17:29:14.320]                     }
[17:29:14.320]                     invisible(muffled)
[17:29:14.320]                   }
[17:29:14.320]                   muffleCondition(cond)
[17:29:14.320]                 })
[17:29:14.320]             }))
[17:29:14.320]             future::FutureResult(value = ...future.value$value, 
[17:29:14.320]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:14.320]                   ...future.rng), globalenv = if (FALSE) 
[17:29:14.320]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:14.320]                     ...future.globalenv.names))
[17:29:14.320]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:14.320]         }, condition = base::local({
[17:29:14.320]             c <- base::c
[17:29:14.320]             inherits <- base::inherits
[17:29:14.320]             invokeRestart <- base::invokeRestart
[17:29:14.320]             length <- base::length
[17:29:14.320]             list <- base::list
[17:29:14.320]             seq.int <- base::seq.int
[17:29:14.320]             signalCondition <- base::signalCondition
[17:29:14.320]             sys.calls <- base::sys.calls
[17:29:14.320]             `[[` <- base::`[[`
[17:29:14.320]             `+` <- base::`+`
[17:29:14.320]             `<<-` <- base::`<<-`
[17:29:14.320]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:14.320]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:14.320]                   3L)]
[17:29:14.320]             }
[17:29:14.320]             function(cond) {
[17:29:14.320]                 is_error <- inherits(cond, "error")
[17:29:14.320]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:14.320]                   NULL)
[17:29:14.320]                 if (is_error) {
[17:29:14.320]                   sessionInformation <- function() {
[17:29:14.320]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:14.320]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:14.320]                       search = base::search(), system = base::Sys.info())
[17:29:14.320]                   }
[17:29:14.320]                   ...future.conditions[[length(...future.conditions) + 
[17:29:14.320]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:14.320]                     cond$call), session = sessionInformation(), 
[17:29:14.320]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:14.320]                   signalCondition(cond)
[17:29:14.320]                 }
[17:29:14.320]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:14.320]                 "immediateCondition"))) {
[17:29:14.320]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:14.320]                   ...future.conditions[[length(...future.conditions) + 
[17:29:14.320]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:14.320]                   if (TRUE && !signal) {
[17:29:14.320]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:14.320]                     {
[17:29:14.320]                       inherits <- base::inherits
[17:29:14.320]                       invokeRestart <- base::invokeRestart
[17:29:14.320]                       is.null <- base::is.null
[17:29:14.320]                       muffled <- FALSE
[17:29:14.320]                       if (inherits(cond, "message")) {
[17:29:14.320]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:14.320]                         if (muffled) 
[17:29:14.320]                           invokeRestart("muffleMessage")
[17:29:14.320]                       }
[17:29:14.320]                       else if (inherits(cond, "warning")) {
[17:29:14.320]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:14.320]                         if (muffled) 
[17:29:14.320]                           invokeRestart("muffleWarning")
[17:29:14.320]                       }
[17:29:14.320]                       else if (inherits(cond, "condition")) {
[17:29:14.320]                         if (!is.null(pattern)) {
[17:29:14.320]                           computeRestarts <- base::computeRestarts
[17:29:14.320]                           grepl <- base::grepl
[17:29:14.320]                           restarts <- computeRestarts(cond)
[17:29:14.320]                           for (restart in restarts) {
[17:29:14.320]                             name <- restart$name
[17:29:14.320]                             if (is.null(name)) 
[17:29:14.320]                               next
[17:29:14.320]                             if (!grepl(pattern, name)) 
[17:29:14.320]                               next
[17:29:14.320]                             invokeRestart(restart)
[17:29:14.320]                             muffled <- TRUE
[17:29:14.320]                             break
[17:29:14.320]                           }
[17:29:14.320]                         }
[17:29:14.320]                       }
[17:29:14.320]                       invisible(muffled)
[17:29:14.320]                     }
[17:29:14.320]                     muffleCondition(cond, pattern = "^muffle")
[17:29:14.320]                   }
[17:29:14.320]                 }
[17:29:14.320]                 else {
[17:29:14.320]                   if (TRUE) {
[17:29:14.320]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:14.320]                     {
[17:29:14.320]                       inherits <- base::inherits
[17:29:14.320]                       invokeRestart <- base::invokeRestart
[17:29:14.320]                       is.null <- base::is.null
[17:29:14.320]                       muffled <- FALSE
[17:29:14.320]                       if (inherits(cond, "message")) {
[17:29:14.320]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:14.320]                         if (muffled) 
[17:29:14.320]                           invokeRestart("muffleMessage")
[17:29:14.320]                       }
[17:29:14.320]                       else if (inherits(cond, "warning")) {
[17:29:14.320]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:14.320]                         if (muffled) 
[17:29:14.320]                           invokeRestart("muffleWarning")
[17:29:14.320]                       }
[17:29:14.320]                       else if (inherits(cond, "condition")) {
[17:29:14.320]                         if (!is.null(pattern)) {
[17:29:14.320]                           computeRestarts <- base::computeRestarts
[17:29:14.320]                           grepl <- base::grepl
[17:29:14.320]                           restarts <- computeRestarts(cond)
[17:29:14.320]                           for (restart in restarts) {
[17:29:14.320]                             name <- restart$name
[17:29:14.320]                             if (is.null(name)) 
[17:29:14.320]                               next
[17:29:14.320]                             if (!grepl(pattern, name)) 
[17:29:14.320]                               next
[17:29:14.320]                             invokeRestart(restart)
[17:29:14.320]                             muffled <- TRUE
[17:29:14.320]                             break
[17:29:14.320]                           }
[17:29:14.320]                         }
[17:29:14.320]                       }
[17:29:14.320]                       invisible(muffled)
[17:29:14.320]                     }
[17:29:14.320]                     muffleCondition(cond, pattern = "^muffle")
[17:29:14.320]                   }
[17:29:14.320]                 }
[17:29:14.320]             }
[17:29:14.320]         }))
[17:29:14.320]     }, error = function(ex) {
[17:29:14.320]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:14.320]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:14.320]                 ...future.rng), started = ...future.startTime, 
[17:29:14.320]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:14.320]             version = "1.8"), class = "FutureResult")
[17:29:14.320]     }, finally = {
[17:29:14.320]         if (!identical(...future.workdir, getwd())) 
[17:29:14.320]             setwd(...future.workdir)
[17:29:14.320]         {
[17:29:14.320]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:14.320]                 ...future.oldOptions$nwarnings <- NULL
[17:29:14.320]             }
[17:29:14.320]             base::options(...future.oldOptions)
[17:29:14.320]             if (.Platform$OS.type == "windows") {
[17:29:14.320]                 old_names <- names(...future.oldEnvVars)
[17:29:14.320]                 envs <- base::Sys.getenv()
[17:29:14.320]                 names <- names(envs)
[17:29:14.320]                 common <- intersect(names, old_names)
[17:29:14.320]                 added <- setdiff(names, old_names)
[17:29:14.320]                 removed <- setdiff(old_names, names)
[17:29:14.320]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:14.320]                   envs[common]]
[17:29:14.320]                 NAMES <- toupper(changed)
[17:29:14.320]                 args <- list()
[17:29:14.320]                 for (kk in seq_along(NAMES)) {
[17:29:14.320]                   name <- changed[[kk]]
[17:29:14.320]                   NAME <- NAMES[[kk]]
[17:29:14.320]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:14.320]                     next
[17:29:14.320]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:14.320]                 }
[17:29:14.320]                 NAMES <- toupper(added)
[17:29:14.320]                 for (kk in seq_along(NAMES)) {
[17:29:14.320]                   name <- added[[kk]]
[17:29:14.320]                   NAME <- NAMES[[kk]]
[17:29:14.320]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:14.320]                     next
[17:29:14.320]                   args[[name]] <- ""
[17:29:14.320]                 }
[17:29:14.320]                 NAMES <- toupper(removed)
[17:29:14.320]                 for (kk in seq_along(NAMES)) {
[17:29:14.320]                   name <- removed[[kk]]
[17:29:14.320]                   NAME <- NAMES[[kk]]
[17:29:14.320]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:14.320]                     next
[17:29:14.320]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:14.320]                 }
[17:29:14.320]                 if (length(args) > 0) 
[17:29:14.320]                   base::do.call(base::Sys.setenv, args = args)
[17:29:14.320]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:14.320]             }
[17:29:14.320]             else {
[17:29:14.320]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:14.320]             }
[17:29:14.320]             {
[17:29:14.320]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:14.320]                   0L) {
[17:29:14.320]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:14.320]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:14.320]                   base::options(opts)
[17:29:14.320]                 }
[17:29:14.320]                 {
[17:29:14.320]                   {
[17:29:14.320]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:14.320]                     NULL
[17:29:14.320]                   }
[17:29:14.320]                   options(future.plan = NULL)
[17:29:14.320]                   if (is.na(NA_character_)) 
[17:29:14.320]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:14.320]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:14.320]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:14.320]                     .init = FALSE)
[17:29:14.320]                 }
[17:29:14.320]             }
[17:29:14.320]         }
[17:29:14.320]     })
[17:29:14.320]     if (TRUE) {
[17:29:14.320]         base::sink(type = "output", split = FALSE)
[17:29:14.320]         if (TRUE) {
[17:29:14.320]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:14.320]         }
[17:29:14.320]         else {
[17:29:14.320]             ...future.result["stdout"] <- base::list(NULL)
[17:29:14.320]         }
[17:29:14.320]         base::close(...future.stdout)
[17:29:14.320]         ...future.stdout <- NULL
[17:29:14.320]     }
[17:29:14.320]     ...future.result$conditions <- ...future.conditions
[17:29:14.320]     ...future.result$finished <- base::Sys.time()
[17:29:14.320]     ...future.result
[17:29:14.320] }
[17:29:14.328] MultisessionFuture started
[17:29:14.329] - Launch lazy future ... done
[17:29:14.329] run() for 'MultisessionFuture' ... done
[17:29:14.354] receiveMessageFromWorker() for ClusterFuture ...
[17:29:14.355] - Validating connection of MultisessionFuture
[17:29:14.356] - received message: FutureResult
[17:29:14.356] - Received FutureResult
[17:29:14.356] - Erased future from FutureRegistry
[17:29:14.357] result() for ClusterFuture ...
[17:29:14.357] - result already collected: FutureResult
[17:29:14.357] result() for ClusterFuture ... done
[17:29:14.357] signalConditions() ...
[17:29:14.357]  - include = 'immediateCondition'
[17:29:14.358]  - exclude = 
[17:29:14.358]  - resignal = FALSE
[17:29:14.358]  - Number of conditions: 1
[17:29:14.358] signalConditions() ... done
[17:29:14.359] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:14.359] A MultisessionFuture was resolved (result was not collected)
[17:29:14.359] getGlobalsAndPackages() ...
[17:29:14.359] Searching for globals...
[17:29:14.361] - globals found: [2] 'list', 'stop'
[17:29:14.361] Searching for globals ... DONE
[17:29:14.361] Resolving globals: FALSE
[17:29:14.362] 
[17:29:14.362] 
[17:29:14.362] getGlobalsAndPackages() ... DONE
[17:29:14.363] run() for 'Future' ...
[17:29:14.363] - state: 'created'
[17:29:14.364] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:14.382] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:14.382] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:14.383]   - Field: 'node'
[17:29:14.383]   - Field: 'label'
[17:29:14.383]   - Field: 'local'
[17:29:14.384]   - Field: 'owner'
[17:29:14.384]   - Field: 'envir'
[17:29:14.384]   - Field: 'workers'
[17:29:14.385]   - Field: 'packages'
[17:29:14.385]   - Field: 'gc'
[17:29:14.385]   - Field: 'conditions'
[17:29:14.385]   - Field: 'persistent'
[17:29:14.386]   - Field: 'expr'
[17:29:14.386]   - Field: 'uuid'
[17:29:14.386]   - Field: 'seed'
[17:29:14.386]   - Field: 'version'
[17:29:14.387]   - Field: 'result'
[17:29:14.387]   - Field: 'asynchronous'
[17:29:14.387]   - Field: 'calls'
[17:29:14.387]   - Field: 'globals'
[17:29:14.388]   - Field: 'stdout'
[17:29:14.388]   - Field: 'earlySignal'
[17:29:14.388]   - Field: 'lazy'
[17:29:14.388]   - Field: 'state'
[17:29:14.389] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:14.389] - Launch lazy future ...
[17:29:14.390] Packages needed by the future expression (n = 0): <none>
[17:29:14.390] Packages needed by future strategies (n = 0): <none>
[17:29:14.391] {
[17:29:14.391]     {
[17:29:14.391]         {
[17:29:14.391]             ...future.startTime <- base::Sys.time()
[17:29:14.391]             {
[17:29:14.391]                 {
[17:29:14.391]                   {
[17:29:14.391]                     {
[17:29:14.391]                       base::local({
[17:29:14.391]                         has_future <- base::requireNamespace("future", 
[17:29:14.391]                           quietly = TRUE)
[17:29:14.391]                         if (has_future) {
[17:29:14.391]                           ns <- base::getNamespace("future")
[17:29:14.391]                           version <- ns[[".package"]][["version"]]
[17:29:14.391]                           if (is.null(version)) 
[17:29:14.391]                             version <- utils::packageVersion("future")
[17:29:14.391]                         }
[17:29:14.391]                         else {
[17:29:14.391]                           version <- NULL
[17:29:14.391]                         }
[17:29:14.391]                         if (!has_future || version < "1.8.0") {
[17:29:14.391]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:14.391]                             "", base::R.version$version.string), 
[17:29:14.391]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:14.391]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:14.391]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:14.391]                               "release", "version")], collapse = " "), 
[17:29:14.391]                             hostname = base::Sys.info()[["nodename"]])
[17:29:14.391]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:14.391]                             info)
[17:29:14.391]                           info <- base::paste(info, collapse = "; ")
[17:29:14.391]                           if (!has_future) {
[17:29:14.391]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:14.391]                               info)
[17:29:14.391]                           }
[17:29:14.391]                           else {
[17:29:14.391]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:14.391]                               info, version)
[17:29:14.391]                           }
[17:29:14.391]                           base::stop(msg)
[17:29:14.391]                         }
[17:29:14.391]                       })
[17:29:14.391]                     }
[17:29:14.391]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:14.391]                     base::options(mc.cores = 1L)
[17:29:14.391]                   }
[17:29:14.391]                   ...future.strategy.old <- future::plan("list")
[17:29:14.391]                   options(future.plan = NULL)
[17:29:14.391]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:14.391]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:14.391]                 }
[17:29:14.391]                 ...future.workdir <- getwd()
[17:29:14.391]             }
[17:29:14.391]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:14.391]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:14.391]         }
[17:29:14.391]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:14.391]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:14.391]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:14.391]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:14.391]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:14.391]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:14.391]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:14.391]             base::names(...future.oldOptions))
[17:29:14.391]     }
[17:29:14.391]     if (FALSE) {
[17:29:14.391]     }
[17:29:14.391]     else {
[17:29:14.391]         if (TRUE) {
[17:29:14.391]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:14.391]                 open = "w")
[17:29:14.391]         }
[17:29:14.391]         else {
[17:29:14.391]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:14.391]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:14.391]         }
[17:29:14.391]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:14.391]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:14.391]             base::sink(type = "output", split = FALSE)
[17:29:14.391]             base::close(...future.stdout)
[17:29:14.391]         }, add = TRUE)
[17:29:14.391]     }
[17:29:14.391]     ...future.frame <- base::sys.nframe()
[17:29:14.391]     ...future.conditions <- base::list()
[17:29:14.391]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:14.391]     if (FALSE) {
[17:29:14.391]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:14.391]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:14.391]     }
[17:29:14.391]     ...future.result <- base::tryCatch({
[17:29:14.391]         base::withCallingHandlers({
[17:29:14.391]             ...future.value <- base::withVisible(base::local({
[17:29:14.391]                 ...future.makeSendCondition <- base::local({
[17:29:14.391]                   sendCondition <- NULL
[17:29:14.391]                   function(frame = 1L) {
[17:29:14.391]                     if (is.function(sendCondition)) 
[17:29:14.391]                       return(sendCondition)
[17:29:14.391]                     ns <- getNamespace("parallel")
[17:29:14.391]                     if (exists("sendData", mode = "function", 
[17:29:14.391]                       envir = ns)) {
[17:29:14.391]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:14.391]                         envir = ns)
[17:29:14.391]                       envir <- sys.frame(frame)
[17:29:14.391]                       master <- NULL
[17:29:14.391]                       while (!identical(envir, .GlobalEnv) && 
[17:29:14.391]                         !identical(envir, emptyenv())) {
[17:29:14.391]                         if (exists("master", mode = "list", envir = envir, 
[17:29:14.391]                           inherits = FALSE)) {
[17:29:14.391]                           master <- get("master", mode = "list", 
[17:29:14.391]                             envir = envir, inherits = FALSE)
[17:29:14.391]                           if (inherits(master, c("SOCKnode", 
[17:29:14.391]                             "SOCK0node"))) {
[17:29:14.391]                             sendCondition <<- function(cond) {
[17:29:14.391]                               data <- list(type = "VALUE", value = cond, 
[17:29:14.391]                                 success = TRUE)
[17:29:14.391]                               parallel_sendData(master, data)
[17:29:14.391]                             }
[17:29:14.391]                             return(sendCondition)
[17:29:14.391]                           }
[17:29:14.391]                         }
[17:29:14.391]                         frame <- frame + 1L
[17:29:14.391]                         envir <- sys.frame(frame)
[17:29:14.391]                       }
[17:29:14.391]                     }
[17:29:14.391]                     sendCondition <<- function(cond) NULL
[17:29:14.391]                   }
[17:29:14.391]                 })
[17:29:14.391]                 withCallingHandlers({
[17:29:14.391]                   list(a = 1, b = 42L, c = stop("Nah!"))
[17:29:14.391]                 }, immediateCondition = function(cond) {
[17:29:14.391]                   sendCondition <- ...future.makeSendCondition()
[17:29:14.391]                   sendCondition(cond)
[17:29:14.391]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:14.391]                   {
[17:29:14.391]                     inherits <- base::inherits
[17:29:14.391]                     invokeRestart <- base::invokeRestart
[17:29:14.391]                     is.null <- base::is.null
[17:29:14.391]                     muffled <- FALSE
[17:29:14.391]                     if (inherits(cond, "message")) {
[17:29:14.391]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:14.391]                       if (muffled) 
[17:29:14.391]                         invokeRestart("muffleMessage")
[17:29:14.391]                     }
[17:29:14.391]                     else if (inherits(cond, "warning")) {
[17:29:14.391]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:14.391]                       if (muffled) 
[17:29:14.391]                         invokeRestart("muffleWarning")
[17:29:14.391]                     }
[17:29:14.391]                     else if (inherits(cond, "condition")) {
[17:29:14.391]                       if (!is.null(pattern)) {
[17:29:14.391]                         computeRestarts <- base::computeRestarts
[17:29:14.391]                         grepl <- base::grepl
[17:29:14.391]                         restarts <- computeRestarts(cond)
[17:29:14.391]                         for (restart in restarts) {
[17:29:14.391]                           name <- restart$name
[17:29:14.391]                           if (is.null(name)) 
[17:29:14.391]                             next
[17:29:14.391]                           if (!grepl(pattern, name)) 
[17:29:14.391]                             next
[17:29:14.391]                           invokeRestart(restart)
[17:29:14.391]                           muffled <- TRUE
[17:29:14.391]                           break
[17:29:14.391]                         }
[17:29:14.391]                       }
[17:29:14.391]                     }
[17:29:14.391]                     invisible(muffled)
[17:29:14.391]                   }
[17:29:14.391]                   muffleCondition(cond)
[17:29:14.391]                 })
[17:29:14.391]             }))
[17:29:14.391]             future::FutureResult(value = ...future.value$value, 
[17:29:14.391]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:14.391]                   ...future.rng), globalenv = if (FALSE) 
[17:29:14.391]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:14.391]                     ...future.globalenv.names))
[17:29:14.391]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:14.391]         }, condition = base::local({
[17:29:14.391]             c <- base::c
[17:29:14.391]             inherits <- base::inherits
[17:29:14.391]             invokeRestart <- base::invokeRestart
[17:29:14.391]             length <- base::length
[17:29:14.391]             list <- base::list
[17:29:14.391]             seq.int <- base::seq.int
[17:29:14.391]             signalCondition <- base::signalCondition
[17:29:14.391]             sys.calls <- base::sys.calls
[17:29:14.391]             `[[` <- base::`[[`
[17:29:14.391]             `+` <- base::`+`
[17:29:14.391]             `<<-` <- base::`<<-`
[17:29:14.391]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:14.391]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:14.391]                   3L)]
[17:29:14.391]             }
[17:29:14.391]             function(cond) {
[17:29:14.391]                 is_error <- inherits(cond, "error")
[17:29:14.391]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:14.391]                   NULL)
[17:29:14.391]                 if (is_error) {
[17:29:14.391]                   sessionInformation <- function() {
[17:29:14.391]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:14.391]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:14.391]                       search = base::search(), system = base::Sys.info())
[17:29:14.391]                   }
[17:29:14.391]                   ...future.conditions[[length(...future.conditions) + 
[17:29:14.391]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:14.391]                     cond$call), session = sessionInformation(), 
[17:29:14.391]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:14.391]                   signalCondition(cond)
[17:29:14.391]                 }
[17:29:14.391]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:14.391]                 "immediateCondition"))) {
[17:29:14.391]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:14.391]                   ...future.conditions[[length(...future.conditions) + 
[17:29:14.391]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:14.391]                   if (TRUE && !signal) {
[17:29:14.391]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:14.391]                     {
[17:29:14.391]                       inherits <- base::inherits
[17:29:14.391]                       invokeRestart <- base::invokeRestart
[17:29:14.391]                       is.null <- base::is.null
[17:29:14.391]                       muffled <- FALSE
[17:29:14.391]                       if (inherits(cond, "message")) {
[17:29:14.391]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:14.391]                         if (muffled) 
[17:29:14.391]                           invokeRestart("muffleMessage")
[17:29:14.391]                       }
[17:29:14.391]                       else if (inherits(cond, "warning")) {
[17:29:14.391]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:14.391]                         if (muffled) 
[17:29:14.391]                           invokeRestart("muffleWarning")
[17:29:14.391]                       }
[17:29:14.391]                       else if (inherits(cond, "condition")) {
[17:29:14.391]                         if (!is.null(pattern)) {
[17:29:14.391]                           computeRestarts <- base::computeRestarts
[17:29:14.391]                           grepl <- base::grepl
[17:29:14.391]                           restarts <- computeRestarts(cond)
[17:29:14.391]                           for (restart in restarts) {
[17:29:14.391]                             name <- restart$name
[17:29:14.391]                             if (is.null(name)) 
[17:29:14.391]                               next
[17:29:14.391]                             if (!grepl(pattern, name)) 
[17:29:14.391]                               next
[17:29:14.391]                             invokeRestart(restart)
[17:29:14.391]                             muffled <- TRUE
[17:29:14.391]                             break
[17:29:14.391]                           }
[17:29:14.391]                         }
[17:29:14.391]                       }
[17:29:14.391]                       invisible(muffled)
[17:29:14.391]                     }
[17:29:14.391]                     muffleCondition(cond, pattern = "^muffle")
[17:29:14.391]                   }
[17:29:14.391]                 }
[17:29:14.391]                 else {
[17:29:14.391]                   if (TRUE) {
[17:29:14.391]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:14.391]                     {
[17:29:14.391]                       inherits <- base::inherits
[17:29:14.391]                       invokeRestart <- base::invokeRestart
[17:29:14.391]                       is.null <- base::is.null
[17:29:14.391]                       muffled <- FALSE
[17:29:14.391]                       if (inherits(cond, "message")) {
[17:29:14.391]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:14.391]                         if (muffled) 
[17:29:14.391]                           invokeRestart("muffleMessage")
[17:29:14.391]                       }
[17:29:14.391]                       else if (inherits(cond, "warning")) {
[17:29:14.391]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:14.391]                         if (muffled) 
[17:29:14.391]                           invokeRestart("muffleWarning")
[17:29:14.391]                       }
[17:29:14.391]                       else if (inherits(cond, "condition")) {
[17:29:14.391]                         if (!is.null(pattern)) {
[17:29:14.391]                           computeRestarts <- base::computeRestarts
[17:29:14.391]                           grepl <- base::grepl
[17:29:14.391]                           restarts <- computeRestarts(cond)
[17:29:14.391]                           for (restart in restarts) {
[17:29:14.391]                             name <- restart$name
[17:29:14.391]                             if (is.null(name)) 
[17:29:14.391]                               next
[17:29:14.391]                             if (!grepl(pattern, name)) 
[17:29:14.391]                               next
[17:29:14.391]                             invokeRestart(restart)
[17:29:14.391]                             muffled <- TRUE
[17:29:14.391]                             break
[17:29:14.391]                           }
[17:29:14.391]                         }
[17:29:14.391]                       }
[17:29:14.391]                       invisible(muffled)
[17:29:14.391]                     }
[17:29:14.391]                     muffleCondition(cond, pattern = "^muffle")
[17:29:14.391]                   }
[17:29:14.391]                 }
[17:29:14.391]             }
[17:29:14.391]         }))
[17:29:14.391]     }, error = function(ex) {
[17:29:14.391]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:14.391]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:14.391]                 ...future.rng), started = ...future.startTime, 
[17:29:14.391]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:14.391]             version = "1.8"), class = "FutureResult")
[17:29:14.391]     }, finally = {
[17:29:14.391]         if (!identical(...future.workdir, getwd())) 
[17:29:14.391]             setwd(...future.workdir)
[17:29:14.391]         {
[17:29:14.391]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:14.391]                 ...future.oldOptions$nwarnings <- NULL
[17:29:14.391]             }
[17:29:14.391]             base::options(...future.oldOptions)
[17:29:14.391]             if (.Platform$OS.type == "windows") {
[17:29:14.391]                 old_names <- names(...future.oldEnvVars)
[17:29:14.391]                 envs <- base::Sys.getenv()
[17:29:14.391]                 names <- names(envs)
[17:29:14.391]                 common <- intersect(names, old_names)
[17:29:14.391]                 added <- setdiff(names, old_names)
[17:29:14.391]                 removed <- setdiff(old_names, names)
[17:29:14.391]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:14.391]                   envs[common]]
[17:29:14.391]                 NAMES <- toupper(changed)
[17:29:14.391]                 args <- list()
[17:29:14.391]                 for (kk in seq_along(NAMES)) {
[17:29:14.391]                   name <- changed[[kk]]
[17:29:14.391]                   NAME <- NAMES[[kk]]
[17:29:14.391]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:14.391]                     next
[17:29:14.391]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:14.391]                 }
[17:29:14.391]                 NAMES <- toupper(added)
[17:29:14.391]                 for (kk in seq_along(NAMES)) {
[17:29:14.391]                   name <- added[[kk]]
[17:29:14.391]                   NAME <- NAMES[[kk]]
[17:29:14.391]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:14.391]                     next
[17:29:14.391]                   args[[name]] <- ""
[17:29:14.391]                 }
[17:29:14.391]                 NAMES <- toupper(removed)
[17:29:14.391]                 for (kk in seq_along(NAMES)) {
[17:29:14.391]                   name <- removed[[kk]]
[17:29:14.391]                   NAME <- NAMES[[kk]]
[17:29:14.391]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:14.391]                     next
[17:29:14.391]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:14.391]                 }
[17:29:14.391]                 if (length(args) > 0) 
[17:29:14.391]                   base::do.call(base::Sys.setenv, args = args)
[17:29:14.391]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:14.391]             }
[17:29:14.391]             else {
[17:29:14.391]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:14.391]             }
[17:29:14.391]             {
[17:29:14.391]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:14.391]                   0L) {
[17:29:14.391]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:14.391]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:14.391]                   base::options(opts)
[17:29:14.391]                 }
[17:29:14.391]                 {
[17:29:14.391]                   {
[17:29:14.391]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:14.391]                     NULL
[17:29:14.391]                   }
[17:29:14.391]                   options(future.plan = NULL)
[17:29:14.391]                   if (is.na(NA_character_)) 
[17:29:14.391]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:14.391]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:14.391]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:14.391]                     .init = FALSE)
[17:29:14.391]                 }
[17:29:14.391]             }
[17:29:14.391]         }
[17:29:14.391]     })
[17:29:14.391]     if (TRUE) {
[17:29:14.391]         base::sink(type = "output", split = FALSE)
[17:29:14.391]         if (TRUE) {
[17:29:14.391]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:14.391]         }
[17:29:14.391]         else {
[17:29:14.391]             ...future.result["stdout"] <- base::list(NULL)
[17:29:14.391]         }
[17:29:14.391]         base::close(...future.stdout)
[17:29:14.391]         ...future.stdout <- NULL
[17:29:14.391]     }
[17:29:14.391]     ...future.result$conditions <- ...future.conditions
[17:29:14.391]     ...future.result$finished <- base::Sys.time()
[17:29:14.391]     ...future.result
[17:29:14.391] }
[17:29:14.401] MultisessionFuture started
[17:29:14.401] - Launch lazy future ... done
[17:29:14.402] run() for 'MultisessionFuture' ... done
[17:29:14.433] receiveMessageFromWorker() for ClusterFuture ...
[17:29:14.433] - Validating connection of MultisessionFuture
[17:29:14.435] - received message: FutureResult
[17:29:14.435] - Received FutureResult
[17:29:14.435] - Erased future from FutureRegistry
[17:29:14.436] result() for ClusterFuture ...
[17:29:14.436] - result already collected: FutureResult
[17:29:14.437] result() for ClusterFuture ... done
[17:29:14.437] signalConditions() ...
[17:29:14.437]  - include = 'immediateCondition'
[17:29:14.438]  - exclude = 
[17:29:14.438]  - resignal = FALSE
[17:29:14.438]  - Number of conditions: 1
[17:29:14.439] signalConditions() ... done
[17:29:14.439] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:14.440] A MultisessionFuture was resolved (result was not collected)
- result = FALSE, recursive = 2 ... DONE
- result = FALSE, recursive = Inf ...
[17:29:14.440] getGlobalsAndPackages() ...
[17:29:14.441] Searching for globals...
[17:29:14.443] - globals found: [3] '{', 'Sys.sleep', 'list'
[17:29:14.444] Searching for globals ... DONE
[17:29:14.444] Resolving globals: FALSE
[17:29:14.445] 
[17:29:14.445] 
[17:29:14.445] getGlobalsAndPackages() ... DONE
[17:29:14.446] run() for 'Future' ...
[17:29:14.446] - state: 'created'
[17:29:14.446] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:14.466] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:14.467] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:14.467]   - Field: 'node'
[17:29:14.467]   - Field: 'label'
[17:29:14.468]   - Field: 'local'
[17:29:14.468]   - Field: 'owner'
[17:29:14.468]   - Field: 'envir'
[17:29:14.468]   - Field: 'workers'
[17:29:14.469]   - Field: 'packages'
[17:29:14.469]   - Field: 'gc'
[17:29:14.469]   - Field: 'conditions'
[17:29:14.470]   - Field: 'persistent'
[17:29:14.470]   - Field: 'expr'
[17:29:14.470]   - Field: 'uuid'
[17:29:14.471]   - Field: 'seed'
[17:29:14.471]   - Field: 'version'
[17:29:14.471]   - Field: 'result'
[17:29:14.472]   - Field: 'asynchronous'
[17:29:14.472]   - Field: 'calls'
[17:29:14.472]   - Field: 'globals'
[17:29:14.473]   - Field: 'stdout'
[17:29:14.473]   - Field: 'earlySignal'
[17:29:14.473]   - Field: 'lazy'
[17:29:14.474]   - Field: 'state'
[17:29:14.474] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:14.474] - Launch lazy future ...
[17:29:14.475] Packages needed by the future expression (n = 0): <none>
[17:29:14.475] Packages needed by future strategies (n = 0): <none>
[17:29:14.476] {
[17:29:14.476]     {
[17:29:14.476]         {
[17:29:14.476]             ...future.startTime <- base::Sys.time()
[17:29:14.476]             {
[17:29:14.476]                 {
[17:29:14.476]                   {
[17:29:14.476]                     {
[17:29:14.476]                       base::local({
[17:29:14.476]                         has_future <- base::requireNamespace("future", 
[17:29:14.476]                           quietly = TRUE)
[17:29:14.476]                         if (has_future) {
[17:29:14.476]                           ns <- base::getNamespace("future")
[17:29:14.476]                           version <- ns[[".package"]][["version"]]
[17:29:14.476]                           if (is.null(version)) 
[17:29:14.476]                             version <- utils::packageVersion("future")
[17:29:14.476]                         }
[17:29:14.476]                         else {
[17:29:14.476]                           version <- NULL
[17:29:14.476]                         }
[17:29:14.476]                         if (!has_future || version < "1.8.0") {
[17:29:14.476]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:14.476]                             "", base::R.version$version.string), 
[17:29:14.476]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:14.476]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:14.476]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:14.476]                               "release", "version")], collapse = " "), 
[17:29:14.476]                             hostname = base::Sys.info()[["nodename"]])
[17:29:14.476]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:14.476]                             info)
[17:29:14.476]                           info <- base::paste(info, collapse = "; ")
[17:29:14.476]                           if (!has_future) {
[17:29:14.476]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:14.476]                               info)
[17:29:14.476]                           }
[17:29:14.476]                           else {
[17:29:14.476]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:14.476]                               info, version)
[17:29:14.476]                           }
[17:29:14.476]                           base::stop(msg)
[17:29:14.476]                         }
[17:29:14.476]                       })
[17:29:14.476]                     }
[17:29:14.476]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:14.476]                     base::options(mc.cores = 1L)
[17:29:14.476]                   }
[17:29:14.476]                   ...future.strategy.old <- future::plan("list")
[17:29:14.476]                   options(future.plan = NULL)
[17:29:14.476]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:14.476]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:14.476]                 }
[17:29:14.476]                 ...future.workdir <- getwd()
[17:29:14.476]             }
[17:29:14.476]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:14.476]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:14.476]         }
[17:29:14.476]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:14.476]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:14.476]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:14.476]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:14.476]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:14.476]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:14.476]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:14.476]             base::names(...future.oldOptions))
[17:29:14.476]     }
[17:29:14.476]     if (FALSE) {
[17:29:14.476]     }
[17:29:14.476]     else {
[17:29:14.476]         if (TRUE) {
[17:29:14.476]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:14.476]                 open = "w")
[17:29:14.476]         }
[17:29:14.476]         else {
[17:29:14.476]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:14.476]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:14.476]         }
[17:29:14.476]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:14.476]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:14.476]             base::sink(type = "output", split = FALSE)
[17:29:14.476]             base::close(...future.stdout)
[17:29:14.476]         }, add = TRUE)
[17:29:14.476]     }
[17:29:14.476]     ...future.frame <- base::sys.nframe()
[17:29:14.476]     ...future.conditions <- base::list()
[17:29:14.476]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:14.476]     if (FALSE) {
[17:29:14.476]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:14.476]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:14.476]     }
[17:29:14.476]     ...future.result <- base::tryCatch({
[17:29:14.476]         base::withCallingHandlers({
[17:29:14.476]             ...future.value <- base::withVisible(base::local({
[17:29:14.476]                 ...future.makeSendCondition <- base::local({
[17:29:14.476]                   sendCondition <- NULL
[17:29:14.476]                   function(frame = 1L) {
[17:29:14.476]                     if (is.function(sendCondition)) 
[17:29:14.476]                       return(sendCondition)
[17:29:14.476]                     ns <- getNamespace("parallel")
[17:29:14.476]                     if (exists("sendData", mode = "function", 
[17:29:14.476]                       envir = ns)) {
[17:29:14.476]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:14.476]                         envir = ns)
[17:29:14.476]                       envir <- sys.frame(frame)
[17:29:14.476]                       master <- NULL
[17:29:14.476]                       while (!identical(envir, .GlobalEnv) && 
[17:29:14.476]                         !identical(envir, emptyenv())) {
[17:29:14.476]                         if (exists("master", mode = "list", envir = envir, 
[17:29:14.476]                           inherits = FALSE)) {
[17:29:14.476]                           master <- get("master", mode = "list", 
[17:29:14.476]                             envir = envir, inherits = FALSE)
[17:29:14.476]                           if (inherits(master, c("SOCKnode", 
[17:29:14.476]                             "SOCK0node"))) {
[17:29:14.476]                             sendCondition <<- function(cond) {
[17:29:14.476]                               data <- list(type = "VALUE", value = cond, 
[17:29:14.476]                                 success = TRUE)
[17:29:14.476]                               parallel_sendData(master, data)
[17:29:14.476]                             }
[17:29:14.476]                             return(sendCondition)
[17:29:14.476]                           }
[17:29:14.476]                         }
[17:29:14.476]                         frame <- frame + 1L
[17:29:14.476]                         envir <- sys.frame(frame)
[17:29:14.476]                       }
[17:29:14.476]                     }
[17:29:14.476]                     sendCondition <<- function(cond) NULL
[17:29:14.476]                   }
[17:29:14.476]                 })
[17:29:14.476]                 withCallingHandlers({
[17:29:14.476]                   {
[17:29:14.476]                     Sys.sleep(0.5)
[17:29:14.476]                     list(a = 1, b = 42L)
[17:29:14.476]                   }
[17:29:14.476]                 }, immediateCondition = function(cond) {
[17:29:14.476]                   sendCondition <- ...future.makeSendCondition()
[17:29:14.476]                   sendCondition(cond)
[17:29:14.476]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:14.476]                   {
[17:29:14.476]                     inherits <- base::inherits
[17:29:14.476]                     invokeRestart <- base::invokeRestart
[17:29:14.476]                     is.null <- base::is.null
[17:29:14.476]                     muffled <- FALSE
[17:29:14.476]                     if (inherits(cond, "message")) {
[17:29:14.476]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:14.476]                       if (muffled) 
[17:29:14.476]                         invokeRestart("muffleMessage")
[17:29:14.476]                     }
[17:29:14.476]                     else if (inherits(cond, "warning")) {
[17:29:14.476]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:14.476]                       if (muffled) 
[17:29:14.476]                         invokeRestart("muffleWarning")
[17:29:14.476]                     }
[17:29:14.476]                     else if (inherits(cond, "condition")) {
[17:29:14.476]                       if (!is.null(pattern)) {
[17:29:14.476]                         computeRestarts <- base::computeRestarts
[17:29:14.476]                         grepl <- base::grepl
[17:29:14.476]                         restarts <- computeRestarts(cond)
[17:29:14.476]                         for (restart in restarts) {
[17:29:14.476]                           name <- restart$name
[17:29:14.476]                           if (is.null(name)) 
[17:29:14.476]                             next
[17:29:14.476]                           if (!grepl(pattern, name)) 
[17:29:14.476]                             next
[17:29:14.476]                           invokeRestart(restart)
[17:29:14.476]                           muffled <- TRUE
[17:29:14.476]                           break
[17:29:14.476]                         }
[17:29:14.476]                       }
[17:29:14.476]                     }
[17:29:14.476]                     invisible(muffled)
[17:29:14.476]                   }
[17:29:14.476]                   muffleCondition(cond)
[17:29:14.476]                 })
[17:29:14.476]             }))
[17:29:14.476]             future::FutureResult(value = ...future.value$value, 
[17:29:14.476]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:14.476]                   ...future.rng), globalenv = if (FALSE) 
[17:29:14.476]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:14.476]                     ...future.globalenv.names))
[17:29:14.476]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:14.476]         }, condition = base::local({
[17:29:14.476]             c <- base::c
[17:29:14.476]             inherits <- base::inherits
[17:29:14.476]             invokeRestart <- base::invokeRestart
[17:29:14.476]             length <- base::length
[17:29:14.476]             list <- base::list
[17:29:14.476]             seq.int <- base::seq.int
[17:29:14.476]             signalCondition <- base::signalCondition
[17:29:14.476]             sys.calls <- base::sys.calls
[17:29:14.476]             `[[` <- base::`[[`
[17:29:14.476]             `+` <- base::`+`
[17:29:14.476]             `<<-` <- base::`<<-`
[17:29:14.476]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:14.476]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:14.476]                   3L)]
[17:29:14.476]             }
[17:29:14.476]             function(cond) {
[17:29:14.476]                 is_error <- inherits(cond, "error")
[17:29:14.476]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:14.476]                   NULL)
[17:29:14.476]                 if (is_error) {
[17:29:14.476]                   sessionInformation <- function() {
[17:29:14.476]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:14.476]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:14.476]                       search = base::search(), system = base::Sys.info())
[17:29:14.476]                   }
[17:29:14.476]                   ...future.conditions[[length(...future.conditions) + 
[17:29:14.476]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:14.476]                     cond$call), session = sessionInformation(), 
[17:29:14.476]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:14.476]                   signalCondition(cond)
[17:29:14.476]                 }
[17:29:14.476]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:14.476]                 "immediateCondition"))) {
[17:29:14.476]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:14.476]                   ...future.conditions[[length(...future.conditions) + 
[17:29:14.476]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:14.476]                   if (TRUE && !signal) {
[17:29:14.476]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:14.476]                     {
[17:29:14.476]                       inherits <- base::inherits
[17:29:14.476]                       invokeRestart <- base::invokeRestart
[17:29:14.476]                       is.null <- base::is.null
[17:29:14.476]                       muffled <- FALSE
[17:29:14.476]                       if (inherits(cond, "message")) {
[17:29:14.476]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:14.476]                         if (muffled) 
[17:29:14.476]                           invokeRestart("muffleMessage")
[17:29:14.476]                       }
[17:29:14.476]                       else if (inherits(cond, "warning")) {
[17:29:14.476]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:14.476]                         if (muffled) 
[17:29:14.476]                           invokeRestart("muffleWarning")
[17:29:14.476]                       }
[17:29:14.476]                       else if (inherits(cond, "condition")) {
[17:29:14.476]                         if (!is.null(pattern)) {
[17:29:14.476]                           computeRestarts <- base::computeRestarts
[17:29:14.476]                           grepl <- base::grepl
[17:29:14.476]                           restarts <- computeRestarts(cond)
[17:29:14.476]                           for (restart in restarts) {
[17:29:14.476]                             name <- restart$name
[17:29:14.476]                             if (is.null(name)) 
[17:29:14.476]                               next
[17:29:14.476]                             if (!grepl(pattern, name)) 
[17:29:14.476]                               next
[17:29:14.476]                             invokeRestart(restart)
[17:29:14.476]                             muffled <- TRUE
[17:29:14.476]                             break
[17:29:14.476]                           }
[17:29:14.476]                         }
[17:29:14.476]                       }
[17:29:14.476]                       invisible(muffled)
[17:29:14.476]                     }
[17:29:14.476]                     muffleCondition(cond, pattern = "^muffle")
[17:29:14.476]                   }
[17:29:14.476]                 }
[17:29:14.476]                 else {
[17:29:14.476]                   if (TRUE) {
[17:29:14.476]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:14.476]                     {
[17:29:14.476]                       inherits <- base::inherits
[17:29:14.476]                       invokeRestart <- base::invokeRestart
[17:29:14.476]                       is.null <- base::is.null
[17:29:14.476]                       muffled <- FALSE
[17:29:14.476]                       if (inherits(cond, "message")) {
[17:29:14.476]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:14.476]                         if (muffled) 
[17:29:14.476]                           invokeRestart("muffleMessage")
[17:29:14.476]                       }
[17:29:14.476]                       else if (inherits(cond, "warning")) {
[17:29:14.476]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:14.476]                         if (muffled) 
[17:29:14.476]                           invokeRestart("muffleWarning")
[17:29:14.476]                       }
[17:29:14.476]                       else if (inherits(cond, "condition")) {
[17:29:14.476]                         if (!is.null(pattern)) {
[17:29:14.476]                           computeRestarts <- base::computeRestarts
[17:29:14.476]                           grepl <- base::grepl
[17:29:14.476]                           restarts <- computeRestarts(cond)
[17:29:14.476]                           for (restart in restarts) {
[17:29:14.476]                             name <- restart$name
[17:29:14.476]                             if (is.null(name)) 
[17:29:14.476]                               next
[17:29:14.476]                             if (!grepl(pattern, name)) 
[17:29:14.476]                               next
[17:29:14.476]                             invokeRestart(restart)
[17:29:14.476]                             muffled <- TRUE
[17:29:14.476]                             break
[17:29:14.476]                           }
[17:29:14.476]                         }
[17:29:14.476]                       }
[17:29:14.476]                       invisible(muffled)
[17:29:14.476]                     }
[17:29:14.476]                     muffleCondition(cond, pattern = "^muffle")
[17:29:14.476]                   }
[17:29:14.476]                 }
[17:29:14.476]             }
[17:29:14.476]         }))
[17:29:14.476]     }, error = function(ex) {
[17:29:14.476]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:14.476]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:14.476]                 ...future.rng), started = ...future.startTime, 
[17:29:14.476]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:14.476]             version = "1.8"), class = "FutureResult")
[17:29:14.476]     }, finally = {
[17:29:14.476]         if (!identical(...future.workdir, getwd())) 
[17:29:14.476]             setwd(...future.workdir)
[17:29:14.476]         {
[17:29:14.476]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:14.476]                 ...future.oldOptions$nwarnings <- NULL
[17:29:14.476]             }
[17:29:14.476]             base::options(...future.oldOptions)
[17:29:14.476]             if (.Platform$OS.type == "windows") {
[17:29:14.476]                 old_names <- names(...future.oldEnvVars)
[17:29:14.476]                 envs <- base::Sys.getenv()
[17:29:14.476]                 names <- names(envs)
[17:29:14.476]                 common <- intersect(names, old_names)
[17:29:14.476]                 added <- setdiff(names, old_names)
[17:29:14.476]                 removed <- setdiff(old_names, names)
[17:29:14.476]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:14.476]                   envs[common]]
[17:29:14.476]                 NAMES <- toupper(changed)
[17:29:14.476]                 args <- list()
[17:29:14.476]                 for (kk in seq_along(NAMES)) {
[17:29:14.476]                   name <- changed[[kk]]
[17:29:14.476]                   NAME <- NAMES[[kk]]
[17:29:14.476]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:14.476]                     next
[17:29:14.476]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:14.476]                 }
[17:29:14.476]                 NAMES <- toupper(added)
[17:29:14.476]                 for (kk in seq_along(NAMES)) {
[17:29:14.476]                   name <- added[[kk]]
[17:29:14.476]                   NAME <- NAMES[[kk]]
[17:29:14.476]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:14.476]                     next
[17:29:14.476]                   args[[name]] <- ""
[17:29:14.476]                 }
[17:29:14.476]                 NAMES <- toupper(removed)
[17:29:14.476]                 for (kk in seq_along(NAMES)) {
[17:29:14.476]                   name <- removed[[kk]]
[17:29:14.476]                   NAME <- NAMES[[kk]]
[17:29:14.476]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:14.476]                     next
[17:29:14.476]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:14.476]                 }
[17:29:14.476]                 if (length(args) > 0) 
[17:29:14.476]                   base::do.call(base::Sys.setenv, args = args)
[17:29:14.476]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:14.476]             }
[17:29:14.476]             else {
[17:29:14.476]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:14.476]             }
[17:29:14.476]             {
[17:29:14.476]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:14.476]                   0L) {
[17:29:14.476]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:14.476]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:14.476]                   base::options(opts)
[17:29:14.476]                 }
[17:29:14.476]                 {
[17:29:14.476]                   {
[17:29:14.476]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:14.476]                     NULL
[17:29:14.476]                   }
[17:29:14.476]                   options(future.plan = NULL)
[17:29:14.476]                   if (is.na(NA_character_)) 
[17:29:14.476]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:14.476]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:14.476]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:14.476]                     .init = FALSE)
[17:29:14.476]                 }
[17:29:14.476]             }
[17:29:14.476]         }
[17:29:14.476]     })
[17:29:14.476]     if (TRUE) {
[17:29:14.476]         base::sink(type = "output", split = FALSE)
[17:29:14.476]         if (TRUE) {
[17:29:14.476]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:14.476]         }
[17:29:14.476]         else {
[17:29:14.476]             ...future.result["stdout"] <- base::list(NULL)
[17:29:14.476]         }
[17:29:14.476]         base::close(...future.stdout)
[17:29:14.476]         ...future.stdout <- NULL
[17:29:14.476]     }
[17:29:14.476]     ...future.result$conditions <- ...future.conditions
[17:29:14.476]     ...future.result$finished <- base::Sys.time()
[17:29:14.476]     ...future.result
[17:29:14.476] }
[17:29:14.486] MultisessionFuture started
[17:29:14.487] - Launch lazy future ... done
[17:29:14.487] run() for 'MultisessionFuture' ... done
[17:29:15.031] receiveMessageFromWorker() for ClusterFuture ...
[17:29:15.031] - Validating connection of MultisessionFuture
[17:29:15.032] - received message: FutureResult
[17:29:15.032] - Received FutureResult
[17:29:15.033] - Erased future from FutureRegistry
[17:29:15.037] result() for ClusterFuture ...
[17:29:15.037] - result already collected: FutureResult
[17:29:15.038] result() for ClusterFuture ... done
[17:29:15.038] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:15.038] A MultisessionFuture was resolved (result was not collected)
[17:29:15.038] getGlobalsAndPackages() ...
[17:29:15.039] Searching for globals...
[17:29:15.041] - globals found: [3] '{', 'Sys.sleep', 'list'
[17:29:15.041] Searching for globals ... DONE
[17:29:15.041] Resolving globals: FALSE
[17:29:15.042] 
[17:29:15.042] 
[17:29:15.042] getGlobalsAndPackages() ... DONE
[17:29:15.043] run() for 'Future' ...
[17:29:15.043] - state: 'created'
[17:29:15.043] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:15.059] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:15.060] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:15.060]   - Field: 'node'
[17:29:15.060]   - Field: 'label'
[17:29:15.060]   - Field: 'local'
[17:29:15.060]   - Field: 'owner'
[17:29:15.061]   - Field: 'envir'
[17:29:15.061]   - Field: 'workers'
[17:29:15.061]   - Field: 'packages'
[17:29:15.061]   - Field: 'gc'
[17:29:15.061]   - Field: 'conditions'
[17:29:15.062]   - Field: 'persistent'
[17:29:15.062]   - Field: 'expr'
[17:29:15.062]   - Field: 'uuid'
[17:29:15.062]   - Field: 'seed'
[17:29:15.062]   - Field: 'version'
[17:29:15.062]   - Field: 'result'
[17:29:15.063]   - Field: 'asynchronous'
[17:29:15.063]   - Field: 'calls'
[17:29:15.063]   - Field: 'globals'
[17:29:15.063]   - Field: 'stdout'
[17:29:15.063]   - Field: 'earlySignal'
[17:29:15.063]   - Field: 'lazy'
[17:29:15.064]   - Field: 'state'
[17:29:15.064] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:15.064] - Launch lazy future ...
[17:29:15.064] Packages needed by the future expression (n = 0): <none>
[17:29:15.064] Packages needed by future strategies (n = 0): <none>
[17:29:15.065] {
[17:29:15.065]     {
[17:29:15.065]         {
[17:29:15.065]             ...future.startTime <- base::Sys.time()
[17:29:15.065]             {
[17:29:15.065]                 {
[17:29:15.065]                   {
[17:29:15.065]                     {
[17:29:15.065]                       base::local({
[17:29:15.065]                         has_future <- base::requireNamespace("future", 
[17:29:15.065]                           quietly = TRUE)
[17:29:15.065]                         if (has_future) {
[17:29:15.065]                           ns <- base::getNamespace("future")
[17:29:15.065]                           version <- ns[[".package"]][["version"]]
[17:29:15.065]                           if (is.null(version)) 
[17:29:15.065]                             version <- utils::packageVersion("future")
[17:29:15.065]                         }
[17:29:15.065]                         else {
[17:29:15.065]                           version <- NULL
[17:29:15.065]                         }
[17:29:15.065]                         if (!has_future || version < "1.8.0") {
[17:29:15.065]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:15.065]                             "", base::R.version$version.string), 
[17:29:15.065]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:15.065]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:15.065]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:15.065]                               "release", "version")], collapse = " "), 
[17:29:15.065]                             hostname = base::Sys.info()[["nodename"]])
[17:29:15.065]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:15.065]                             info)
[17:29:15.065]                           info <- base::paste(info, collapse = "; ")
[17:29:15.065]                           if (!has_future) {
[17:29:15.065]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:15.065]                               info)
[17:29:15.065]                           }
[17:29:15.065]                           else {
[17:29:15.065]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:15.065]                               info, version)
[17:29:15.065]                           }
[17:29:15.065]                           base::stop(msg)
[17:29:15.065]                         }
[17:29:15.065]                       })
[17:29:15.065]                     }
[17:29:15.065]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:15.065]                     base::options(mc.cores = 1L)
[17:29:15.065]                   }
[17:29:15.065]                   ...future.strategy.old <- future::plan("list")
[17:29:15.065]                   options(future.plan = NULL)
[17:29:15.065]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:15.065]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:15.065]                 }
[17:29:15.065]                 ...future.workdir <- getwd()
[17:29:15.065]             }
[17:29:15.065]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:15.065]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:15.065]         }
[17:29:15.065]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:15.065]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:15.065]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:15.065]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:15.065]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:15.065]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:15.065]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:15.065]             base::names(...future.oldOptions))
[17:29:15.065]     }
[17:29:15.065]     if (FALSE) {
[17:29:15.065]     }
[17:29:15.065]     else {
[17:29:15.065]         if (TRUE) {
[17:29:15.065]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:15.065]                 open = "w")
[17:29:15.065]         }
[17:29:15.065]         else {
[17:29:15.065]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:15.065]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:15.065]         }
[17:29:15.065]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:15.065]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:15.065]             base::sink(type = "output", split = FALSE)
[17:29:15.065]             base::close(...future.stdout)
[17:29:15.065]         }, add = TRUE)
[17:29:15.065]     }
[17:29:15.065]     ...future.frame <- base::sys.nframe()
[17:29:15.065]     ...future.conditions <- base::list()
[17:29:15.065]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:15.065]     if (FALSE) {
[17:29:15.065]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:15.065]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:15.065]     }
[17:29:15.065]     ...future.result <- base::tryCatch({
[17:29:15.065]         base::withCallingHandlers({
[17:29:15.065]             ...future.value <- base::withVisible(base::local({
[17:29:15.065]                 ...future.makeSendCondition <- base::local({
[17:29:15.065]                   sendCondition <- NULL
[17:29:15.065]                   function(frame = 1L) {
[17:29:15.065]                     if (is.function(sendCondition)) 
[17:29:15.065]                       return(sendCondition)
[17:29:15.065]                     ns <- getNamespace("parallel")
[17:29:15.065]                     if (exists("sendData", mode = "function", 
[17:29:15.065]                       envir = ns)) {
[17:29:15.065]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:15.065]                         envir = ns)
[17:29:15.065]                       envir <- sys.frame(frame)
[17:29:15.065]                       master <- NULL
[17:29:15.065]                       while (!identical(envir, .GlobalEnv) && 
[17:29:15.065]                         !identical(envir, emptyenv())) {
[17:29:15.065]                         if (exists("master", mode = "list", envir = envir, 
[17:29:15.065]                           inherits = FALSE)) {
[17:29:15.065]                           master <- get("master", mode = "list", 
[17:29:15.065]                             envir = envir, inherits = FALSE)
[17:29:15.065]                           if (inherits(master, c("SOCKnode", 
[17:29:15.065]                             "SOCK0node"))) {
[17:29:15.065]                             sendCondition <<- function(cond) {
[17:29:15.065]                               data <- list(type = "VALUE", value = cond, 
[17:29:15.065]                                 success = TRUE)
[17:29:15.065]                               parallel_sendData(master, data)
[17:29:15.065]                             }
[17:29:15.065]                             return(sendCondition)
[17:29:15.065]                           }
[17:29:15.065]                         }
[17:29:15.065]                         frame <- frame + 1L
[17:29:15.065]                         envir <- sys.frame(frame)
[17:29:15.065]                       }
[17:29:15.065]                     }
[17:29:15.065]                     sendCondition <<- function(cond) NULL
[17:29:15.065]                   }
[17:29:15.065]                 })
[17:29:15.065]                 withCallingHandlers({
[17:29:15.065]                   {
[17:29:15.065]                     Sys.sleep(0.5)
[17:29:15.065]                     list(a = 1, b = 42L)
[17:29:15.065]                   }
[17:29:15.065]                 }, immediateCondition = function(cond) {
[17:29:15.065]                   sendCondition <- ...future.makeSendCondition()
[17:29:15.065]                   sendCondition(cond)
[17:29:15.065]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:15.065]                   {
[17:29:15.065]                     inherits <- base::inherits
[17:29:15.065]                     invokeRestart <- base::invokeRestart
[17:29:15.065]                     is.null <- base::is.null
[17:29:15.065]                     muffled <- FALSE
[17:29:15.065]                     if (inherits(cond, "message")) {
[17:29:15.065]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:15.065]                       if (muffled) 
[17:29:15.065]                         invokeRestart("muffleMessage")
[17:29:15.065]                     }
[17:29:15.065]                     else if (inherits(cond, "warning")) {
[17:29:15.065]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:15.065]                       if (muffled) 
[17:29:15.065]                         invokeRestart("muffleWarning")
[17:29:15.065]                     }
[17:29:15.065]                     else if (inherits(cond, "condition")) {
[17:29:15.065]                       if (!is.null(pattern)) {
[17:29:15.065]                         computeRestarts <- base::computeRestarts
[17:29:15.065]                         grepl <- base::grepl
[17:29:15.065]                         restarts <- computeRestarts(cond)
[17:29:15.065]                         for (restart in restarts) {
[17:29:15.065]                           name <- restart$name
[17:29:15.065]                           if (is.null(name)) 
[17:29:15.065]                             next
[17:29:15.065]                           if (!grepl(pattern, name)) 
[17:29:15.065]                             next
[17:29:15.065]                           invokeRestart(restart)
[17:29:15.065]                           muffled <- TRUE
[17:29:15.065]                           break
[17:29:15.065]                         }
[17:29:15.065]                       }
[17:29:15.065]                     }
[17:29:15.065]                     invisible(muffled)
[17:29:15.065]                   }
[17:29:15.065]                   muffleCondition(cond)
[17:29:15.065]                 })
[17:29:15.065]             }))
[17:29:15.065]             future::FutureResult(value = ...future.value$value, 
[17:29:15.065]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:15.065]                   ...future.rng), globalenv = if (FALSE) 
[17:29:15.065]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:15.065]                     ...future.globalenv.names))
[17:29:15.065]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:15.065]         }, condition = base::local({
[17:29:15.065]             c <- base::c
[17:29:15.065]             inherits <- base::inherits
[17:29:15.065]             invokeRestart <- base::invokeRestart
[17:29:15.065]             length <- base::length
[17:29:15.065]             list <- base::list
[17:29:15.065]             seq.int <- base::seq.int
[17:29:15.065]             signalCondition <- base::signalCondition
[17:29:15.065]             sys.calls <- base::sys.calls
[17:29:15.065]             `[[` <- base::`[[`
[17:29:15.065]             `+` <- base::`+`
[17:29:15.065]             `<<-` <- base::`<<-`
[17:29:15.065]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:15.065]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:15.065]                   3L)]
[17:29:15.065]             }
[17:29:15.065]             function(cond) {
[17:29:15.065]                 is_error <- inherits(cond, "error")
[17:29:15.065]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:15.065]                   NULL)
[17:29:15.065]                 if (is_error) {
[17:29:15.065]                   sessionInformation <- function() {
[17:29:15.065]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:15.065]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:15.065]                       search = base::search(), system = base::Sys.info())
[17:29:15.065]                   }
[17:29:15.065]                   ...future.conditions[[length(...future.conditions) + 
[17:29:15.065]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:15.065]                     cond$call), session = sessionInformation(), 
[17:29:15.065]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:15.065]                   signalCondition(cond)
[17:29:15.065]                 }
[17:29:15.065]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:15.065]                 "immediateCondition"))) {
[17:29:15.065]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:15.065]                   ...future.conditions[[length(...future.conditions) + 
[17:29:15.065]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:15.065]                   if (TRUE && !signal) {
[17:29:15.065]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:15.065]                     {
[17:29:15.065]                       inherits <- base::inherits
[17:29:15.065]                       invokeRestart <- base::invokeRestart
[17:29:15.065]                       is.null <- base::is.null
[17:29:15.065]                       muffled <- FALSE
[17:29:15.065]                       if (inherits(cond, "message")) {
[17:29:15.065]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:15.065]                         if (muffled) 
[17:29:15.065]                           invokeRestart("muffleMessage")
[17:29:15.065]                       }
[17:29:15.065]                       else if (inherits(cond, "warning")) {
[17:29:15.065]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:15.065]                         if (muffled) 
[17:29:15.065]                           invokeRestart("muffleWarning")
[17:29:15.065]                       }
[17:29:15.065]                       else if (inherits(cond, "condition")) {
[17:29:15.065]                         if (!is.null(pattern)) {
[17:29:15.065]                           computeRestarts <- base::computeRestarts
[17:29:15.065]                           grepl <- base::grepl
[17:29:15.065]                           restarts <- computeRestarts(cond)
[17:29:15.065]                           for (restart in restarts) {
[17:29:15.065]                             name <- restart$name
[17:29:15.065]                             if (is.null(name)) 
[17:29:15.065]                               next
[17:29:15.065]                             if (!grepl(pattern, name)) 
[17:29:15.065]                               next
[17:29:15.065]                             invokeRestart(restart)
[17:29:15.065]                             muffled <- TRUE
[17:29:15.065]                             break
[17:29:15.065]                           }
[17:29:15.065]                         }
[17:29:15.065]                       }
[17:29:15.065]                       invisible(muffled)
[17:29:15.065]                     }
[17:29:15.065]                     muffleCondition(cond, pattern = "^muffle")
[17:29:15.065]                   }
[17:29:15.065]                 }
[17:29:15.065]                 else {
[17:29:15.065]                   if (TRUE) {
[17:29:15.065]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:15.065]                     {
[17:29:15.065]                       inherits <- base::inherits
[17:29:15.065]                       invokeRestart <- base::invokeRestart
[17:29:15.065]                       is.null <- base::is.null
[17:29:15.065]                       muffled <- FALSE
[17:29:15.065]                       if (inherits(cond, "message")) {
[17:29:15.065]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:15.065]                         if (muffled) 
[17:29:15.065]                           invokeRestart("muffleMessage")
[17:29:15.065]                       }
[17:29:15.065]                       else if (inherits(cond, "warning")) {
[17:29:15.065]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:15.065]                         if (muffled) 
[17:29:15.065]                           invokeRestart("muffleWarning")
[17:29:15.065]                       }
[17:29:15.065]                       else if (inherits(cond, "condition")) {
[17:29:15.065]                         if (!is.null(pattern)) {
[17:29:15.065]                           computeRestarts <- base::computeRestarts
[17:29:15.065]                           grepl <- base::grepl
[17:29:15.065]                           restarts <- computeRestarts(cond)
[17:29:15.065]                           for (restart in restarts) {
[17:29:15.065]                             name <- restart$name
[17:29:15.065]                             if (is.null(name)) 
[17:29:15.065]                               next
[17:29:15.065]                             if (!grepl(pattern, name)) 
[17:29:15.065]                               next
[17:29:15.065]                             invokeRestart(restart)
[17:29:15.065]                             muffled <- TRUE
[17:29:15.065]                             break
[17:29:15.065]                           }
[17:29:15.065]                         }
[17:29:15.065]                       }
[17:29:15.065]                       invisible(muffled)
[17:29:15.065]                     }
[17:29:15.065]                     muffleCondition(cond, pattern = "^muffle")
[17:29:15.065]                   }
[17:29:15.065]                 }
[17:29:15.065]             }
[17:29:15.065]         }))
[17:29:15.065]     }, error = function(ex) {
[17:29:15.065]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:15.065]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:15.065]                 ...future.rng), started = ...future.startTime, 
[17:29:15.065]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:15.065]             version = "1.8"), class = "FutureResult")
[17:29:15.065]     }, finally = {
[17:29:15.065]         if (!identical(...future.workdir, getwd())) 
[17:29:15.065]             setwd(...future.workdir)
[17:29:15.065]         {
[17:29:15.065]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:15.065]                 ...future.oldOptions$nwarnings <- NULL
[17:29:15.065]             }
[17:29:15.065]             base::options(...future.oldOptions)
[17:29:15.065]             if (.Platform$OS.type == "windows") {
[17:29:15.065]                 old_names <- names(...future.oldEnvVars)
[17:29:15.065]                 envs <- base::Sys.getenv()
[17:29:15.065]                 names <- names(envs)
[17:29:15.065]                 common <- intersect(names, old_names)
[17:29:15.065]                 added <- setdiff(names, old_names)
[17:29:15.065]                 removed <- setdiff(old_names, names)
[17:29:15.065]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:15.065]                   envs[common]]
[17:29:15.065]                 NAMES <- toupper(changed)
[17:29:15.065]                 args <- list()
[17:29:15.065]                 for (kk in seq_along(NAMES)) {
[17:29:15.065]                   name <- changed[[kk]]
[17:29:15.065]                   NAME <- NAMES[[kk]]
[17:29:15.065]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:15.065]                     next
[17:29:15.065]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:15.065]                 }
[17:29:15.065]                 NAMES <- toupper(added)
[17:29:15.065]                 for (kk in seq_along(NAMES)) {
[17:29:15.065]                   name <- added[[kk]]
[17:29:15.065]                   NAME <- NAMES[[kk]]
[17:29:15.065]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:15.065]                     next
[17:29:15.065]                   args[[name]] <- ""
[17:29:15.065]                 }
[17:29:15.065]                 NAMES <- toupper(removed)
[17:29:15.065]                 for (kk in seq_along(NAMES)) {
[17:29:15.065]                   name <- removed[[kk]]
[17:29:15.065]                   NAME <- NAMES[[kk]]
[17:29:15.065]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:15.065]                     next
[17:29:15.065]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:15.065]                 }
[17:29:15.065]                 if (length(args) > 0) 
[17:29:15.065]                   base::do.call(base::Sys.setenv, args = args)
[17:29:15.065]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:15.065]             }
[17:29:15.065]             else {
[17:29:15.065]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:15.065]             }
[17:29:15.065]             {
[17:29:15.065]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:15.065]                   0L) {
[17:29:15.065]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:15.065]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:15.065]                   base::options(opts)
[17:29:15.065]                 }
[17:29:15.065]                 {
[17:29:15.065]                   {
[17:29:15.065]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:15.065]                     NULL
[17:29:15.065]                   }
[17:29:15.065]                   options(future.plan = NULL)
[17:29:15.065]                   if (is.na(NA_character_)) 
[17:29:15.065]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:15.065]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:15.065]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:15.065]                     .init = FALSE)
[17:29:15.065]                 }
[17:29:15.065]             }
[17:29:15.065]         }
[17:29:15.065]     })
[17:29:15.065]     if (TRUE) {
[17:29:15.065]         base::sink(type = "output", split = FALSE)
[17:29:15.065]         if (TRUE) {
[17:29:15.065]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:15.065]         }
[17:29:15.065]         else {
[17:29:15.065]             ...future.result["stdout"] <- base::list(NULL)
[17:29:15.065]         }
[17:29:15.065]         base::close(...future.stdout)
[17:29:15.065]         ...future.stdout <- NULL
[17:29:15.065]     }
[17:29:15.065]     ...future.result$conditions <- ...future.conditions
[17:29:15.065]     ...future.result$finished <- base::Sys.time()
[17:29:15.065]     ...future.result
[17:29:15.065] }
[17:29:15.071] MultisessionFuture started
[17:29:15.072] - Launch lazy future ... done
[17:29:15.072] run() for 'MultisessionFuture' ... done
[17:29:15.608] receiveMessageFromWorker() for ClusterFuture ...
[17:29:15.609] - Validating connection of MultisessionFuture
[17:29:15.609] - received message: FutureResult
[17:29:15.610] - Received FutureResult
[17:29:15.610] - Erased future from FutureRegistry
[17:29:15.611] result() for ClusterFuture ...
[17:29:15.611] - result already collected: FutureResult
[17:29:15.611] result() for ClusterFuture ... done
[17:29:15.612] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:15.612] A MultisessionFuture was resolved (result was not collected)
- w/ exception ...
[17:29:15.613] getGlobalsAndPackages() ...
[17:29:15.613] Searching for globals...
[17:29:15.615] - globals found: [2] 'list', 'stop'
[17:29:15.615] Searching for globals ... DONE
[17:29:15.615] Resolving globals: FALSE
[17:29:15.616] 
[17:29:15.617] 
[17:29:15.617] getGlobalsAndPackages() ... DONE
[17:29:15.617] run() for 'Future' ...
[17:29:15.618] - state: 'created'
[17:29:15.618] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:15.645] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:15.646] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:15.646]   - Field: 'node'
[17:29:15.646]   - Field: 'label'
[17:29:15.647]   - Field: 'local'
[17:29:15.647]   - Field: 'owner'
[17:29:15.648]   - Field: 'envir'
[17:29:15.648]   - Field: 'workers'
[17:29:15.648]   - Field: 'packages'
[17:29:15.649]   - Field: 'gc'
[17:29:15.649]   - Field: 'conditions'
[17:29:15.650]   - Field: 'persistent'
[17:29:15.650]   - Field: 'expr'
[17:29:15.650]   - Field: 'uuid'
[17:29:15.651]   - Field: 'seed'
[17:29:15.651]   - Field: 'version'
[17:29:15.651]   - Field: 'result'
[17:29:15.652]   - Field: 'asynchronous'
[17:29:15.652]   - Field: 'calls'
[17:29:15.653]   - Field: 'globals'
[17:29:15.653]   - Field: 'stdout'
[17:29:15.653]   - Field: 'earlySignal'
[17:29:15.654]   - Field: 'lazy'
[17:29:15.654]   - Field: 'state'
[17:29:15.655] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:15.655] - Launch lazy future ...
[17:29:15.656] Packages needed by the future expression (n = 0): <none>
[17:29:15.656] Packages needed by future strategies (n = 0): <none>
[17:29:15.657] {
[17:29:15.657]     {
[17:29:15.657]         {
[17:29:15.657]             ...future.startTime <- base::Sys.time()
[17:29:15.657]             {
[17:29:15.657]                 {
[17:29:15.657]                   {
[17:29:15.657]                     {
[17:29:15.657]                       base::local({
[17:29:15.657]                         has_future <- base::requireNamespace("future", 
[17:29:15.657]                           quietly = TRUE)
[17:29:15.657]                         if (has_future) {
[17:29:15.657]                           ns <- base::getNamespace("future")
[17:29:15.657]                           version <- ns[[".package"]][["version"]]
[17:29:15.657]                           if (is.null(version)) 
[17:29:15.657]                             version <- utils::packageVersion("future")
[17:29:15.657]                         }
[17:29:15.657]                         else {
[17:29:15.657]                           version <- NULL
[17:29:15.657]                         }
[17:29:15.657]                         if (!has_future || version < "1.8.0") {
[17:29:15.657]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:15.657]                             "", base::R.version$version.string), 
[17:29:15.657]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:15.657]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:15.657]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:15.657]                               "release", "version")], collapse = " "), 
[17:29:15.657]                             hostname = base::Sys.info()[["nodename"]])
[17:29:15.657]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:15.657]                             info)
[17:29:15.657]                           info <- base::paste(info, collapse = "; ")
[17:29:15.657]                           if (!has_future) {
[17:29:15.657]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:15.657]                               info)
[17:29:15.657]                           }
[17:29:15.657]                           else {
[17:29:15.657]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:15.657]                               info, version)
[17:29:15.657]                           }
[17:29:15.657]                           base::stop(msg)
[17:29:15.657]                         }
[17:29:15.657]                       })
[17:29:15.657]                     }
[17:29:15.657]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:15.657]                     base::options(mc.cores = 1L)
[17:29:15.657]                   }
[17:29:15.657]                   ...future.strategy.old <- future::plan("list")
[17:29:15.657]                   options(future.plan = NULL)
[17:29:15.657]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:15.657]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:15.657]                 }
[17:29:15.657]                 ...future.workdir <- getwd()
[17:29:15.657]             }
[17:29:15.657]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:15.657]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:15.657]         }
[17:29:15.657]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:15.657]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:15.657]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:15.657]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:15.657]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:15.657]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:15.657]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:15.657]             base::names(...future.oldOptions))
[17:29:15.657]     }
[17:29:15.657]     if (FALSE) {
[17:29:15.657]     }
[17:29:15.657]     else {
[17:29:15.657]         if (TRUE) {
[17:29:15.657]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:15.657]                 open = "w")
[17:29:15.657]         }
[17:29:15.657]         else {
[17:29:15.657]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:15.657]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:15.657]         }
[17:29:15.657]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:15.657]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:15.657]             base::sink(type = "output", split = FALSE)
[17:29:15.657]             base::close(...future.stdout)
[17:29:15.657]         }, add = TRUE)
[17:29:15.657]     }
[17:29:15.657]     ...future.frame <- base::sys.nframe()
[17:29:15.657]     ...future.conditions <- base::list()
[17:29:15.657]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:15.657]     if (FALSE) {
[17:29:15.657]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:15.657]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:15.657]     }
[17:29:15.657]     ...future.result <- base::tryCatch({
[17:29:15.657]         base::withCallingHandlers({
[17:29:15.657]             ...future.value <- base::withVisible(base::local({
[17:29:15.657]                 ...future.makeSendCondition <- base::local({
[17:29:15.657]                   sendCondition <- NULL
[17:29:15.657]                   function(frame = 1L) {
[17:29:15.657]                     if (is.function(sendCondition)) 
[17:29:15.657]                       return(sendCondition)
[17:29:15.657]                     ns <- getNamespace("parallel")
[17:29:15.657]                     if (exists("sendData", mode = "function", 
[17:29:15.657]                       envir = ns)) {
[17:29:15.657]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:15.657]                         envir = ns)
[17:29:15.657]                       envir <- sys.frame(frame)
[17:29:15.657]                       master <- NULL
[17:29:15.657]                       while (!identical(envir, .GlobalEnv) && 
[17:29:15.657]                         !identical(envir, emptyenv())) {
[17:29:15.657]                         if (exists("master", mode = "list", envir = envir, 
[17:29:15.657]                           inherits = FALSE)) {
[17:29:15.657]                           master <- get("master", mode = "list", 
[17:29:15.657]                             envir = envir, inherits = FALSE)
[17:29:15.657]                           if (inherits(master, c("SOCKnode", 
[17:29:15.657]                             "SOCK0node"))) {
[17:29:15.657]                             sendCondition <<- function(cond) {
[17:29:15.657]                               data <- list(type = "VALUE", value = cond, 
[17:29:15.657]                                 success = TRUE)
[17:29:15.657]                               parallel_sendData(master, data)
[17:29:15.657]                             }
[17:29:15.657]                             return(sendCondition)
[17:29:15.657]                           }
[17:29:15.657]                         }
[17:29:15.657]                         frame <- frame + 1L
[17:29:15.657]                         envir <- sys.frame(frame)
[17:29:15.657]                       }
[17:29:15.657]                     }
[17:29:15.657]                     sendCondition <<- function(cond) NULL
[17:29:15.657]                   }
[17:29:15.657]                 })
[17:29:15.657]                 withCallingHandlers({
[17:29:15.657]                   list(a = 1, b = 42L, c = stop("Nah!"))
[17:29:15.657]                 }, immediateCondition = function(cond) {
[17:29:15.657]                   sendCondition <- ...future.makeSendCondition()
[17:29:15.657]                   sendCondition(cond)
[17:29:15.657]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:15.657]                   {
[17:29:15.657]                     inherits <- base::inherits
[17:29:15.657]                     invokeRestart <- base::invokeRestart
[17:29:15.657]                     is.null <- base::is.null
[17:29:15.657]                     muffled <- FALSE
[17:29:15.657]                     if (inherits(cond, "message")) {
[17:29:15.657]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:15.657]                       if (muffled) 
[17:29:15.657]                         invokeRestart("muffleMessage")
[17:29:15.657]                     }
[17:29:15.657]                     else if (inherits(cond, "warning")) {
[17:29:15.657]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:15.657]                       if (muffled) 
[17:29:15.657]                         invokeRestart("muffleWarning")
[17:29:15.657]                     }
[17:29:15.657]                     else if (inherits(cond, "condition")) {
[17:29:15.657]                       if (!is.null(pattern)) {
[17:29:15.657]                         computeRestarts <- base::computeRestarts
[17:29:15.657]                         grepl <- base::grepl
[17:29:15.657]                         restarts <- computeRestarts(cond)
[17:29:15.657]                         for (restart in restarts) {
[17:29:15.657]                           name <- restart$name
[17:29:15.657]                           if (is.null(name)) 
[17:29:15.657]                             next
[17:29:15.657]                           if (!grepl(pattern, name)) 
[17:29:15.657]                             next
[17:29:15.657]                           invokeRestart(restart)
[17:29:15.657]                           muffled <- TRUE
[17:29:15.657]                           break
[17:29:15.657]                         }
[17:29:15.657]                       }
[17:29:15.657]                     }
[17:29:15.657]                     invisible(muffled)
[17:29:15.657]                   }
[17:29:15.657]                   muffleCondition(cond)
[17:29:15.657]                 })
[17:29:15.657]             }))
[17:29:15.657]             future::FutureResult(value = ...future.value$value, 
[17:29:15.657]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:15.657]                   ...future.rng), globalenv = if (FALSE) 
[17:29:15.657]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:15.657]                     ...future.globalenv.names))
[17:29:15.657]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:15.657]         }, condition = base::local({
[17:29:15.657]             c <- base::c
[17:29:15.657]             inherits <- base::inherits
[17:29:15.657]             invokeRestart <- base::invokeRestart
[17:29:15.657]             length <- base::length
[17:29:15.657]             list <- base::list
[17:29:15.657]             seq.int <- base::seq.int
[17:29:15.657]             signalCondition <- base::signalCondition
[17:29:15.657]             sys.calls <- base::sys.calls
[17:29:15.657]             `[[` <- base::`[[`
[17:29:15.657]             `+` <- base::`+`
[17:29:15.657]             `<<-` <- base::`<<-`
[17:29:15.657]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:15.657]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:15.657]                   3L)]
[17:29:15.657]             }
[17:29:15.657]             function(cond) {
[17:29:15.657]                 is_error <- inherits(cond, "error")
[17:29:15.657]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:15.657]                   NULL)
[17:29:15.657]                 if (is_error) {
[17:29:15.657]                   sessionInformation <- function() {
[17:29:15.657]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:15.657]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:15.657]                       search = base::search(), system = base::Sys.info())
[17:29:15.657]                   }
[17:29:15.657]                   ...future.conditions[[length(...future.conditions) + 
[17:29:15.657]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:15.657]                     cond$call), session = sessionInformation(), 
[17:29:15.657]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:15.657]                   signalCondition(cond)
[17:29:15.657]                 }
[17:29:15.657]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:15.657]                 "immediateCondition"))) {
[17:29:15.657]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:15.657]                   ...future.conditions[[length(...future.conditions) + 
[17:29:15.657]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:15.657]                   if (TRUE && !signal) {
[17:29:15.657]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:15.657]                     {
[17:29:15.657]                       inherits <- base::inherits
[17:29:15.657]                       invokeRestart <- base::invokeRestart
[17:29:15.657]                       is.null <- base::is.null
[17:29:15.657]                       muffled <- FALSE
[17:29:15.657]                       if (inherits(cond, "message")) {
[17:29:15.657]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:15.657]                         if (muffled) 
[17:29:15.657]                           invokeRestart("muffleMessage")
[17:29:15.657]                       }
[17:29:15.657]                       else if (inherits(cond, "warning")) {
[17:29:15.657]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:15.657]                         if (muffled) 
[17:29:15.657]                           invokeRestart("muffleWarning")
[17:29:15.657]                       }
[17:29:15.657]                       else if (inherits(cond, "condition")) {
[17:29:15.657]                         if (!is.null(pattern)) {
[17:29:15.657]                           computeRestarts <- base::computeRestarts
[17:29:15.657]                           grepl <- base::grepl
[17:29:15.657]                           restarts <- computeRestarts(cond)
[17:29:15.657]                           for (restart in restarts) {
[17:29:15.657]                             name <- restart$name
[17:29:15.657]                             if (is.null(name)) 
[17:29:15.657]                               next
[17:29:15.657]                             if (!grepl(pattern, name)) 
[17:29:15.657]                               next
[17:29:15.657]                             invokeRestart(restart)
[17:29:15.657]                             muffled <- TRUE
[17:29:15.657]                             break
[17:29:15.657]                           }
[17:29:15.657]                         }
[17:29:15.657]                       }
[17:29:15.657]                       invisible(muffled)
[17:29:15.657]                     }
[17:29:15.657]                     muffleCondition(cond, pattern = "^muffle")
[17:29:15.657]                   }
[17:29:15.657]                 }
[17:29:15.657]                 else {
[17:29:15.657]                   if (TRUE) {
[17:29:15.657]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:15.657]                     {
[17:29:15.657]                       inherits <- base::inherits
[17:29:15.657]                       invokeRestart <- base::invokeRestart
[17:29:15.657]                       is.null <- base::is.null
[17:29:15.657]                       muffled <- FALSE
[17:29:15.657]                       if (inherits(cond, "message")) {
[17:29:15.657]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:15.657]                         if (muffled) 
[17:29:15.657]                           invokeRestart("muffleMessage")
[17:29:15.657]                       }
[17:29:15.657]                       else if (inherits(cond, "warning")) {
[17:29:15.657]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:15.657]                         if (muffled) 
[17:29:15.657]                           invokeRestart("muffleWarning")
[17:29:15.657]                       }
[17:29:15.657]                       else if (inherits(cond, "condition")) {
[17:29:15.657]                         if (!is.null(pattern)) {
[17:29:15.657]                           computeRestarts <- base::computeRestarts
[17:29:15.657]                           grepl <- base::grepl
[17:29:15.657]                           restarts <- computeRestarts(cond)
[17:29:15.657]                           for (restart in restarts) {
[17:29:15.657]                             name <- restart$name
[17:29:15.657]                             if (is.null(name)) 
[17:29:15.657]                               next
[17:29:15.657]                             if (!grepl(pattern, name)) 
[17:29:15.657]                               next
[17:29:15.657]                             invokeRestart(restart)
[17:29:15.657]                             muffled <- TRUE
[17:29:15.657]                             break
[17:29:15.657]                           }
[17:29:15.657]                         }
[17:29:15.657]                       }
[17:29:15.657]                       invisible(muffled)
[17:29:15.657]                     }
[17:29:15.657]                     muffleCondition(cond, pattern = "^muffle")
[17:29:15.657]                   }
[17:29:15.657]                 }
[17:29:15.657]             }
[17:29:15.657]         }))
[17:29:15.657]     }, error = function(ex) {
[17:29:15.657]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:15.657]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:15.657]                 ...future.rng), started = ...future.startTime, 
[17:29:15.657]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:15.657]             version = "1.8"), class = "FutureResult")
[17:29:15.657]     }, finally = {
[17:29:15.657]         if (!identical(...future.workdir, getwd())) 
[17:29:15.657]             setwd(...future.workdir)
[17:29:15.657]         {
[17:29:15.657]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:15.657]                 ...future.oldOptions$nwarnings <- NULL
[17:29:15.657]             }
[17:29:15.657]             base::options(...future.oldOptions)
[17:29:15.657]             if (.Platform$OS.type == "windows") {
[17:29:15.657]                 old_names <- names(...future.oldEnvVars)
[17:29:15.657]                 envs <- base::Sys.getenv()
[17:29:15.657]                 names <- names(envs)
[17:29:15.657]                 common <- intersect(names, old_names)
[17:29:15.657]                 added <- setdiff(names, old_names)
[17:29:15.657]                 removed <- setdiff(old_names, names)
[17:29:15.657]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:15.657]                   envs[common]]
[17:29:15.657]                 NAMES <- toupper(changed)
[17:29:15.657]                 args <- list()
[17:29:15.657]                 for (kk in seq_along(NAMES)) {
[17:29:15.657]                   name <- changed[[kk]]
[17:29:15.657]                   NAME <- NAMES[[kk]]
[17:29:15.657]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:15.657]                     next
[17:29:15.657]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:15.657]                 }
[17:29:15.657]                 NAMES <- toupper(added)
[17:29:15.657]                 for (kk in seq_along(NAMES)) {
[17:29:15.657]                   name <- added[[kk]]
[17:29:15.657]                   NAME <- NAMES[[kk]]
[17:29:15.657]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:15.657]                     next
[17:29:15.657]                   args[[name]] <- ""
[17:29:15.657]                 }
[17:29:15.657]                 NAMES <- toupper(removed)
[17:29:15.657]                 for (kk in seq_along(NAMES)) {
[17:29:15.657]                   name <- removed[[kk]]
[17:29:15.657]                   NAME <- NAMES[[kk]]
[17:29:15.657]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:15.657]                     next
[17:29:15.657]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:15.657]                 }
[17:29:15.657]                 if (length(args) > 0) 
[17:29:15.657]                   base::do.call(base::Sys.setenv, args = args)
[17:29:15.657]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:15.657]             }
[17:29:15.657]             else {
[17:29:15.657]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:15.657]             }
[17:29:15.657]             {
[17:29:15.657]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:15.657]                   0L) {
[17:29:15.657]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:15.657]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:15.657]                   base::options(opts)
[17:29:15.657]                 }
[17:29:15.657]                 {
[17:29:15.657]                   {
[17:29:15.657]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:15.657]                     NULL
[17:29:15.657]                   }
[17:29:15.657]                   options(future.plan = NULL)
[17:29:15.657]                   if (is.na(NA_character_)) 
[17:29:15.657]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:15.657]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:15.657]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:15.657]                     .init = FALSE)
[17:29:15.657]                 }
[17:29:15.657]             }
[17:29:15.657]         }
[17:29:15.657]     })
[17:29:15.657]     if (TRUE) {
[17:29:15.657]         base::sink(type = "output", split = FALSE)
[17:29:15.657]         if (TRUE) {
[17:29:15.657]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:15.657]         }
[17:29:15.657]         else {
[17:29:15.657]             ...future.result["stdout"] <- base::list(NULL)
[17:29:15.657]         }
[17:29:15.657]         base::close(...future.stdout)
[17:29:15.657]         ...future.stdout <- NULL
[17:29:15.657]     }
[17:29:15.657]     ...future.result$conditions <- ...future.conditions
[17:29:15.657]     ...future.result$finished <- base::Sys.time()
[17:29:15.657]     ...future.result
[17:29:15.657] }
[17:29:15.669] MultisessionFuture started
[17:29:15.669] - Launch lazy future ... done
[17:29:15.670] run() for 'MultisessionFuture' ... done
[17:29:15.703] receiveMessageFromWorker() for ClusterFuture ...
[17:29:15.703] - Validating connection of MultisessionFuture
[17:29:15.704] - received message: FutureResult
[17:29:15.705] - Received FutureResult
[17:29:15.705] - Erased future from FutureRegistry
[17:29:15.706] result() for ClusterFuture ...
[17:29:15.706] - result already collected: FutureResult
[17:29:15.706] result() for ClusterFuture ... done
[17:29:15.707] signalConditions() ...
[17:29:15.707]  - include = 'immediateCondition'
[17:29:15.707]  - exclude = 
[17:29:15.707]  - resignal = FALSE
[17:29:15.708]  - Number of conditions: 1
[17:29:15.708] signalConditions() ... done
[17:29:15.708] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:15.709] A MultisessionFuture was resolved (result was not collected)
[17:29:15.709] getGlobalsAndPackages() ...
[17:29:15.709] Searching for globals...
[17:29:15.711] - globals found: [2] 'list', 'stop'
[17:29:15.711] Searching for globals ... DONE
[17:29:15.711] Resolving globals: FALSE
[17:29:15.712] 
[17:29:15.712] 
[17:29:15.713] getGlobalsAndPackages() ... DONE
[17:29:15.713] run() for 'Future' ...
[17:29:15.714] - state: 'created'
[17:29:15.714] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:15.736] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:15.737] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:15.737]   - Field: 'node'
[17:29:15.738]   - Field: 'label'
[17:29:15.738]   - Field: 'local'
[17:29:15.739]   - Field: 'owner'
[17:29:15.739]   - Field: 'envir'
[17:29:15.739]   - Field: 'workers'
[17:29:15.740]   - Field: 'packages'
[17:29:15.740]   - Field: 'gc'
[17:29:15.740]   - Field: 'conditions'
[17:29:15.741]   - Field: 'persistent'
[17:29:15.741]   - Field: 'expr'
[17:29:15.741]   - Field: 'uuid'
[17:29:15.742]   - Field: 'seed'
[17:29:15.742]   - Field: 'version'
[17:29:15.742]   - Field: 'result'
[17:29:15.742]   - Field: 'asynchronous'
[17:29:15.742]   - Field: 'calls'
[17:29:15.743]   - Field: 'globals'
[17:29:15.743]   - Field: 'stdout'
[17:29:15.743]   - Field: 'earlySignal'
[17:29:15.743]   - Field: 'lazy'
[17:29:15.744]   - Field: 'state'
[17:29:15.744] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:15.744] - Launch lazy future ...
[17:29:15.745] Packages needed by the future expression (n = 0): <none>
[17:29:15.745] Packages needed by future strategies (n = 0): <none>
[17:29:15.746] {
[17:29:15.746]     {
[17:29:15.746]         {
[17:29:15.746]             ...future.startTime <- base::Sys.time()
[17:29:15.746]             {
[17:29:15.746]                 {
[17:29:15.746]                   {
[17:29:15.746]                     {
[17:29:15.746]                       base::local({
[17:29:15.746]                         has_future <- base::requireNamespace("future", 
[17:29:15.746]                           quietly = TRUE)
[17:29:15.746]                         if (has_future) {
[17:29:15.746]                           ns <- base::getNamespace("future")
[17:29:15.746]                           version <- ns[[".package"]][["version"]]
[17:29:15.746]                           if (is.null(version)) 
[17:29:15.746]                             version <- utils::packageVersion("future")
[17:29:15.746]                         }
[17:29:15.746]                         else {
[17:29:15.746]                           version <- NULL
[17:29:15.746]                         }
[17:29:15.746]                         if (!has_future || version < "1.8.0") {
[17:29:15.746]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:15.746]                             "", base::R.version$version.string), 
[17:29:15.746]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:15.746]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:15.746]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:15.746]                               "release", "version")], collapse = " "), 
[17:29:15.746]                             hostname = base::Sys.info()[["nodename"]])
[17:29:15.746]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:15.746]                             info)
[17:29:15.746]                           info <- base::paste(info, collapse = "; ")
[17:29:15.746]                           if (!has_future) {
[17:29:15.746]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:15.746]                               info)
[17:29:15.746]                           }
[17:29:15.746]                           else {
[17:29:15.746]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:15.746]                               info, version)
[17:29:15.746]                           }
[17:29:15.746]                           base::stop(msg)
[17:29:15.746]                         }
[17:29:15.746]                       })
[17:29:15.746]                     }
[17:29:15.746]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:15.746]                     base::options(mc.cores = 1L)
[17:29:15.746]                   }
[17:29:15.746]                   ...future.strategy.old <- future::plan("list")
[17:29:15.746]                   options(future.plan = NULL)
[17:29:15.746]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:15.746]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:15.746]                 }
[17:29:15.746]                 ...future.workdir <- getwd()
[17:29:15.746]             }
[17:29:15.746]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:15.746]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:15.746]         }
[17:29:15.746]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:15.746]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:15.746]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:15.746]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:15.746]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:15.746]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:15.746]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:15.746]             base::names(...future.oldOptions))
[17:29:15.746]     }
[17:29:15.746]     if (FALSE) {
[17:29:15.746]     }
[17:29:15.746]     else {
[17:29:15.746]         if (TRUE) {
[17:29:15.746]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:15.746]                 open = "w")
[17:29:15.746]         }
[17:29:15.746]         else {
[17:29:15.746]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:15.746]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:15.746]         }
[17:29:15.746]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:15.746]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:15.746]             base::sink(type = "output", split = FALSE)
[17:29:15.746]             base::close(...future.stdout)
[17:29:15.746]         }, add = TRUE)
[17:29:15.746]     }
[17:29:15.746]     ...future.frame <- base::sys.nframe()
[17:29:15.746]     ...future.conditions <- base::list()
[17:29:15.746]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:15.746]     if (FALSE) {
[17:29:15.746]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:15.746]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:15.746]     }
[17:29:15.746]     ...future.result <- base::tryCatch({
[17:29:15.746]         base::withCallingHandlers({
[17:29:15.746]             ...future.value <- base::withVisible(base::local({
[17:29:15.746]                 ...future.makeSendCondition <- base::local({
[17:29:15.746]                   sendCondition <- NULL
[17:29:15.746]                   function(frame = 1L) {
[17:29:15.746]                     if (is.function(sendCondition)) 
[17:29:15.746]                       return(sendCondition)
[17:29:15.746]                     ns <- getNamespace("parallel")
[17:29:15.746]                     if (exists("sendData", mode = "function", 
[17:29:15.746]                       envir = ns)) {
[17:29:15.746]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:15.746]                         envir = ns)
[17:29:15.746]                       envir <- sys.frame(frame)
[17:29:15.746]                       master <- NULL
[17:29:15.746]                       while (!identical(envir, .GlobalEnv) && 
[17:29:15.746]                         !identical(envir, emptyenv())) {
[17:29:15.746]                         if (exists("master", mode = "list", envir = envir, 
[17:29:15.746]                           inherits = FALSE)) {
[17:29:15.746]                           master <- get("master", mode = "list", 
[17:29:15.746]                             envir = envir, inherits = FALSE)
[17:29:15.746]                           if (inherits(master, c("SOCKnode", 
[17:29:15.746]                             "SOCK0node"))) {
[17:29:15.746]                             sendCondition <<- function(cond) {
[17:29:15.746]                               data <- list(type = "VALUE", value = cond, 
[17:29:15.746]                                 success = TRUE)
[17:29:15.746]                               parallel_sendData(master, data)
[17:29:15.746]                             }
[17:29:15.746]                             return(sendCondition)
[17:29:15.746]                           }
[17:29:15.746]                         }
[17:29:15.746]                         frame <- frame + 1L
[17:29:15.746]                         envir <- sys.frame(frame)
[17:29:15.746]                       }
[17:29:15.746]                     }
[17:29:15.746]                     sendCondition <<- function(cond) NULL
[17:29:15.746]                   }
[17:29:15.746]                 })
[17:29:15.746]                 withCallingHandlers({
[17:29:15.746]                   list(a = 1, b = 42L, c = stop("Nah!"))
[17:29:15.746]                 }, immediateCondition = function(cond) {
[17:29:15.746]                   sendCondition <- ...future.makeSendCondition()
[17:29:15.746]                   sendCondition(cond)
[17:29:15.746]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:15.746]                   {
[17:29:15.746]                     inherits <- base::inherits
[17:29:15.746]                     invokeRestart <- base::invokeRestart
[17:29:15.746]                     is.null <- base::is.null
[17:29:15.746]                     muffled <- FALSE
[17:29:15.746]                     if (inherits(cond, "message")) {
[17:29:15.746]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:15.746]                       if (muffled) 
[17:29:15.746]                         invokeRestart("muffleMessage")
[17:29:15.746]                     }
[17:29:15.746]                     else if (inherits(cond, "warning")) {
[17:29:15.746]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:15.746]                       if (muffled) 
[17:29:15.746]                         invokeRestart("muffleWarning")
[17:29:15.746]                     }
[17:29:15.746]                     else if (inherits(cond, "condition")) {
[17:29:15.746]                       if (!is.null(pattern)) {
[17:29:15.746]                         computeRestarts <- base::computeRestarts
[17:29:15.746]                         grepl <- base::grepl
[17:29:15.746]                         restarts <- computeRestarts(cond)
[17:29:15.746]                         for (restart in restarts) {
[17:29:15.746]                           name <- restart$name
[17:29:15.746]                           if (is.null(name)) 
[17:29:15.746]                             next
[17:29:15.746]                           if (!grepl(pattern, name)) 
[17:29:15.746]                             next
[17:29:15.746]                           invokeRestart(restart)
[17:29:15.746]                           muffled <- TRUE
[17:29:15.746]                           break
[17:29:15.746]                         }
[17:29:15.746]                       }
[17:29:15.746]                     }
[17:29:15.746]                     invisible(muffled)
[17:29:15.746]                   }
[17:29:15.746]                   muffleCondition(cond)
[17:29:15.746]                 })
[17:29:15.746]             }))
[17:29:15.746]             future::FutureResult(value = ...future.value$value, 
[17:29:15.746]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:15.746]                   ...future.rng), globalenv = if (FALSE) 
[17:29:15.746]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:15.746]                     ...future.globalenv.names))
[17:29:15.746]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:15.746]         }, condition = base::local({
[17:29:15.746]             c <- base::c
[17:29:15.746]             inherits <- base::inherits
[17:29:15.746]             invokeRestart <- base::invokeRestart
[17:29:15.746]             length <- base::length
[17:29:15.746]             list <- base::list
[17:29:15.746]             seq.int <- base::seq.int
[17:29:15.746]             signalCondition <- base::signalCondition
[17:29:15.746]             sys.calls <- base::sys.calls
[17:29:15.746]             `[[` <- base::`[[`
[17:29:15.746]             `+` <- base::`+`
[17:29:15.746]             `<<-` <- base::`<<-`
[17:29:15.746]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:15.746]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:15.746]                   3L)]
[17:29:15.746]             }
[17:29:15.746]             function(cond) {
[17:29:15.746]                 is_error <- inherits(cond, "error")
[17:29:15.746]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:15.746]                   NULL)
[17:29:15.746]                 if (is_error) {
[17:29:15.746]                   sessionInformation <- function() {
[17:29:15.746]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:15.746]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:15.746]                       search = base::search(), system = base::Sys.info())
[17:29:15.746]                   }
[17:29:15.746]                   ...future.conditions[[length(...future.conditions) + 
[17:29:15.746]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:15.746]                     cond$call), session = sessionInformation(), 
[17:29:15.746]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:15.746]                   signalCondition(cond)
[17:29:15.746]                 }
[17:29:15.746]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:15.746]                 "immediateCondition"))) {
[17:29:15.746]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:15.746]                   ...future.conditions[[length(...future.conditions) + 
[17:29:15.746]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:15.746]                   if (TRUE && !signal) {
[17:29:15.746]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:15.746]                     {
[17:29:15.746]                       inherits <- base::inherits
[17:29:15.746]                       invokeRestart <- base::invokeRestart
[17:29:15.746]                       is.null <- base::is.null
[17:29:15.746]                       muffled <- FALSE
[17:29:15.746]                       if (inherits(cond, "message")) {
[17:29:15.746]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:15.746]                         if (muffled) 
[17:29:15.746]                           invokeRestart("muffleMessage")
[17:29:15.746]                       }
[17:29:15.746]                       else if (inherits(cond, "warning")) {
[17:29:15.746]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:15.746]                         if (muffled) 
[17:29:15.746]                           invokeRestart("muffleWarning")
[17:29:15.746]                       }
[17:29:15.746]                       else if (inherits(cond, "condition")) {
[17:29:15.746]                         if (!is.null(pattern)) {
[17:29:15.746]                           computeRestarts <- base::computeRestarts
[17:29:15.746]                           grepl <- base::grepl
[17:29:15.746]                           restarts <- computeRestarts(cond)
[17:29:15.746]                           for (restart in restarts) {
[17:29:15.746]                             name <- restart$name
[17:29:15.746]                             if (is.null(name)) 
[17:29:15.746]                               next
[17:29:15.746]                             if (!grepl(pattern, name)) 
[17:29:15.746]                               next
[17:29:15.746]                             invokeRestart(restart)
[17:29:15.746]                             muffled <- TRUE
[17:29:15.746]                             break
[17:29:15.746]                           }
[17:29:15.746]                         }
[17:29:15.746]                       }
[17:29:15.746]                       invisible(muffled)
[17:29:15.746]                     }
[17:29:15.746]                     muffleCondition(cond, pattern = "^muffle")
[17:29:15.746]                   }
[17:29:15.746]                 }
[17:29:15.746]                 else {
[17:29:15.746]                   if (TRUE) {
[17:29:15.746]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:15.746]                     {
[17:29:15.746]                       inherits <- base::inherits
[17:29:15.746]                       invokeRestart <- base::invokeRestart
[17:29:15.746]                       is.null <- base::is.null
[17:29:15.746]                       muffled <- FALSE
[17:29:15.746]                       if (inherits(cond, "message")) {
[17:29:15.746]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:15.746]                         if (muffled) 
[17:29:15.746]                           invokeRestart("muffleMessage")
[17:29:15.746]                       }
[17:29:15.746]                       else if (inherits(cond, "warning")) {
[17:29:15.746]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:15.746]                         if (muffled) 
[17:29:15.746]                           invokeRestart("muffleWarning")
[17:29:15.746]                       }
[17:29:15.746]                       else if (inherits(cond, "condition")) {
[17:29:15.746]                         if (!is.null(pattern)) {
[17:29:15.746]                           computeRestarts <- base::computeRestarts
[17:29:15.746]                           grepl <- base::grepl
[17:29:15.746]                           restarts <- computeRestarts(cond)
[17:29:15.746]                           for (restart in restarts) {
[17:29:15.746]                             name <- restart$name
[17:29:15.746]                             if (is.null(name)) 
[17:29:15.746]                               next
[17:29:15.746]                             if (!grepl(pattern, name)) 
[17:29:15.746]                               next
[17:29:15.746]                             invokeRestart(restart)
[17:29:15.746]                             muffled <- TRUE
[17:29:15.746]                             break
[17:29:15.746]                           }
[17:29:15.746]                         }
[17:29:15.746]                       }
[17:29:15.746]                       invisible(muffled)
[17:29:15.746]                     }
[17:29:15.746]                     muffleCondition(cond, pattern = "^muffle")
[17:29:15.746]                   }
[17:29:15.746]                 }
[17:29:15.746]             }
[17:29:15.746]         }))
[17:29:15.746]     }, error = function(ex) {
[17:29:15.746]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:15.746]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:15.746]                 ...future.rng), started = ...future.startTime, 
[17:29:15.746]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:15.746]             version = "1.8"), class = "FutureResult")
[17:29:15.746]     }, finally = {
[17:29:15.746]         if (!identical(...future.workdir, getwd())) 
[17:29:15.746]             setwd(...future.workdir)
[17:29:15.746]         {
[17:29:15.746]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:15.746]                 ...future.oldOptions$nwarnings <- NULL
[17:29:15.746]             }
[17:29:15.746]             base::options(...future.oldOptions)
[17:29:15.746]             if (.Platform$OS.type == "windows") {
[17:29:15.746]                 old_names <- names(...future.oldEnvVars)
[17:29:15.746]                 envs <- base::Sys.getenv()
[17:29:15.746]                 names <- names(envs)
[17:29:15.746]                 common <- intersect(names, old_names)
[17:29:15.746]                 added <- setdiff(names, old_names)
[17:29:15.746]                 removed <- setdiff(old_names, names)
[17:29:15.746]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:15.746]                   envs[common]]
[17:29:15.746]                 NAMES <- toupper(changed)
[17:29:15.746]                 args <- list()
[17:29:15.746]                 for (kk in seq_along(NAMES)) {
[17:29:15.746]                   name <- changed[[kk]]
[17:29:15.746]                   NAME <- NAMES[[kk]]
[17:29:15.746]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:15.746]                     next
[17:29:15.746]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:15.746]                 }
[17:29:15.746]                 NAMES <- toupper(added)
[17:29:15.746]                 for (kk in seq_along(NAMES)) {
[17:29:15.746]                   name <- added[[kk]]
[17:29:15.746]                   NAME <- NAMES[[kk]]
[17:29:15.746]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:15.746]                     next
[17:29:15.746]                   args[[name]] <- ""
[17:29:15.746]                 }
[17:29:15.746]                 NAMES <- toupper(removed)
[17:29:15.746]                 for (kk in seq_along(NAMES)) {
[17:29:15.746]                   name <- removed[[kk]]
[17:29:15.746]                   NAME <- NAMES[[kk]]
[17:29:15.746]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:15.746]                     next
[17:29:15.746]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:15.746]                 }
[17:29:15.746]                 if (length(args) > 0) 
[17:29:15.746]                   base::do.call(base::Sys.setenv, args = args)
[17:29:15.746]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:15.746]             }
[17:29:15.746]             else {
[17:29:15.746]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:15.746]             }
[17:29:15.746]             {
[17:29:15.746]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:15.746]                   0L) {
[17:29:15.746]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:15.746]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:15.746]                   base::options(opts)
[17:29:15.746]                 }
[17:29:15.746]                 {
[17:29:15.746]                   {
[17:29:15.746]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:15.746]                     NULL
[17:29:15.746]                   }
[17:29:15.746]                   options(future.plan = NULL)
[17:29:15.746]                   if (is.na(NA_character_)) 
[17:29:15.746]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:15.746]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:15.746]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:15.746]                     .init = FALSE)
[17:29:15.746]                 }
[17:29:15.746]             }
[17:29:15.746]         }
[17:29:15.746]     })
[17:29:15.746]     if (TRUE) {
[17:29:15.746]         base::sink(type = "output", split = FALSE)
[17:29:15.746]         if (TRUE) {
[17:29:15.746]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:15.746]         }
[17:29:15.746]         else {
[17:29:15.746]             ...future.result["stdout"] <- base::list(NULL)
[17:29:15.746]         }
[17:29:15.746]         base::close(...future.stdout)
[17:29:15.746]         ...future.stdout <- NULL
[17:29:15.746]     }
[17:29:15.746]     ...future.result$conditions <- ...future.conditions
[17:29:15.746]     ...future.result$finished <- base::Sys.time()
[17:29:15.746]     ...future.result
[17:29:15.746] }
[17:29:15.757] MultisessionFuture started
[17:29:15.757] - Launch lazy future ... done
[17:29:15.758] run() for 'MultisessionFuture' ... done
[17:29:15.782] receiveMessageFromWorker() for ClusterFuture ...
[17:29:15.783] - Validating connection of MultisessionFuture
[17:29:15.784] - received message: FutureResult
[17:29:15.784] - Received FutureResult
[17:29:15.785] - Erased future from FutureRegistry
[17:29:15.785] result() for ClusterFuture ...
[17:29:15.785] - result already collected: FutureResult
[17:29:15.786] result() for ClusterFuture ... done
[17:29:15.786] signalConditions() ...
[17:29:15.786]  - include = 'immediateCondition'
[17:29:15.787]  - exclude = 
[17:29:15.787]  - resignal = FALSE
[17:29:15.787]  - Number of conditions: 1
[17:29:15.788] signalConditions() ... done
[17:29:15.788] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:15.788] A MultisessionFuture was resolved (result was not collected)
- result = FALSE, recursive = Inf ... DONE
- result = TRUE, recursive = FALSE ...
[17:29:15.789] getGlobalsAndPackages() ...
[17:29:15.789] Searching for globals...
[17:29:15.792] - globals found: [3] '{', 'Sys.sleep', 'list'
[17:29:15.792] Searching for globals ... DONE
[17:29:15.793] Resolving globals: FALSE
[17:29:15.793] 
[17:29:15.794] 
[17:29:15.794] getGlobalsAndPackages() ... DONE
[17:29:15.795] run() for 'Future' ...
[17:29:15.795] - state: 'created'
[17:29:15.795] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:15.816] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:15.816] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:15.817]   - Field: 'node'
[17:29:15.817]   - Field: 'label'
[17:29:15.817]   - Field: 'local'
[17:29:15.817]   - Field: 'owner'
[17:29:15.818]   - Field: 'envir'
[17:29:15.818]   - Field: 'workers'
[17:29:15.818]   - Field: 'packages'
[17:29:15.819]   - Field: 'gc'
[17:29:15.819]   - Field: 'conditions'
[17:29:15.819]   - Field: 'persistent'
[17:29:15.819]   - Field: 'expr'
[17:29:15.820]   - Field: 'uuid'
[17:29:15.820]   - Field: 'seed'
[17:29:15.820]   - Field: 'version'
[17:29:15.821]   - Field: 'result'
[17:29:15.821]   - Field: 'asynchronous'
[17:29:15.821]   - Field: 'calls'
[17:29:15.821]   - Field: 'globals'
[17:29:15.822]   - Field: 'stdout'
[17:29:15.822]   - Field: 'earlySignal'
[17:29:15.822]   - Field: 'lazy'
[17:29:15.823]   - Field: 'state'
[17:29:15.823] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:15.823] - Launch lazy future ...
[17:29:15.824] Packages needed by the future expression (n = 0): <none>
[17:29:15.824] Packages needed by future strategies (n = 0): <none>
[17:29:15.825] {
[17:29:15.825]     {
[17:29:15.825]         {
[17:29:15.825]             ...future.startTime <- base::Sys.time()
[17:29:15.825]             {
[17:29:15.825]                 {
[17:29:15.825]                   {
[17:29:15.825]                     {
[17:29:15.825]                       base::local({
[17:29:15.825]                         has_future <- base::requireNamespace("future", 
[17:29:15.825]                           quietly = TRUE)
[17:29:15.825]                         if (has_future) {
[17:29:15.825]                           ns <- base::getNamespace("future")
[17:29:15.825]                           version <- ns[[".package"]][["version"]]
[17:29:15.825]                           if (is.null(version)) 
[17:29:15.825]                             version <- utils::packageVersion("future")
[17:29:15.825]                         }
[17:29:15.825]                         else {
[17:29:15.825]                           version <- NULL
[17:29:15.825]                         }
[17:29:15.825]                         if (!has_future || version < "1.8.0") {
[17:29:15.825]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:15.825]                             "", base::R.version$version.string), 
[17:29:15.825]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:15.825]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:15.825]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:15.825]                               "release", "version")], collapse = " "), 
[17:29:15.825]                             hostname = base::Sys.info()[["nodename"]])
[17:29:15.825]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:15.825]                             info)
[17:29:15.825]                           info <- base::paste(info, collapse = "; ")
[17:29:15.825]                           if (!has_future) {
[17:29:15.825]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:15.825]                               info)
[17:29:15.825]                           }
[17:29:15.825]                           else {
[17:29:15.825]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:15.825]                               info, version)
[17:29:15.825]                           }
[17:29:15.825]                           base::stop(msg)
[17:29:15.825]                         }
[17:29:15.825]                       })
[17:29:15.825]                     }
[17:29:15.825]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:15.825]                     base::options(mc.cores = 1L)
[17:29:15.825]                   }
[17:29:15.825]                   ...future.strategy.old <- future::plan("list")
[17:29:15.825]                   options(future.plan = NULL)
[17:29:15.825]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:15.825]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:15.825]                 }
[17:29:15.825]                 ...future.workdir <- getwd()
[17:29:15.825]             }
[17:29:15.825]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:15.825]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:15.825]         }
[17:29:15.825]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:15.825]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:15.825]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:15.825]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:15.825]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:15.825]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:15.825]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:15.825]             base::names(...future.oldOptions))
[17:29:15.825]     }
[17:29:15.825]     if (FALSE) {
[17:29:15.825]     }
[17:29:15.825]     else {
[17:29:15.825]         if (TRUE) {
[17:29:15.825]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:15.825]                 open = "w")
[17:29:15.825]         }
[17:29:15.825]         else {
[17:29:15.825]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:15.825]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:15.825]         }
[17:29:15.825]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:15.825]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:15.825]             base::sink(type = "output", split = FALSE)
[17:29:15.825]             base::close(...future.stdout)
[17:29:15.825]         }, add = TRUE)
[17:29:15.825]     }
[17:29:15.825]     ...future.frame <- base::sys.nframe()
[17:29:15.825]     ...future.conditions <- base::list()
[17:29:15.825]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:15.825]     if (FALSE) {
[17:29:15.825]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:15.825]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:15.825]     }
[17:29:15.825]     ...future.result <- base::tryCatch({
[17:29:15.825]         base::withCallingHandlers({
[17:29:15.825]             ...future.value <- base::withVisible(base::local({
[17:29:15.825]                 ...future.makeSendCondition <- base::local({
[17:29:15.825]                   sendCondition <- NULL
[17:29:15.825]                   function(frame = 1L) {
[17:29:15.825]                     if (is.function(sendCondition)) 
[17:29:15.825]                       return(sendCondition)
[17:29:15.825]                     ns <- getNamespace("parallel")
[17:29:15.825]                     if (exists("sendData", mode = "function", 
[17:29:15.825]                       envir = ns)) {
[17:29:15.825]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:15.825]                         envir = ns)
[17:29:15.825]                       envir <- sys.frame(frame)
[17:29:15.825]                       master <- NULL
[17:29:15.825]                       while (!identical(envir, .GlobalEnv) && 
[17:29:15.825]                         !identical(envir, emptyenv())) {
[17:29:15.825]                         if (exists("master", mode = "list", envir = envir, 
[17:29:15.825]                           inherits = FALSE)) {
[17:29:15.825]                           master <- get("master", mode = "list", 
[17:29:15.825]                             envir = envir, inherits = FALSE)
[17:29:15.825]                           if (inherits(master, c("SOCKnode", 
[17:29:15.825]                             "SOCK0node"))) {
[17:29:15.825]                             sendCondition <<- function(cond) {
[17:29:15.825]                               data <- list(type = "VALUE", value = cond, 
[17:29:15.825]                                 success = TRUE)
[17:29:15.825]                               parallel_sendData(master, data)
[17:29:15.825]                             }
[17:29:15.825]                             return(sendCondition)
[17:29:15.825]                           }
[17:29:15.825]                         }
[17:29:15.825]                         frame <- frame + 1L
[17:29:15.825]                         envir <- sys.frame(frame)
[17:29:15.825]                       }
[17:29:15.825]                     }
[17:29:15.825]                     sendCondition <<- function(cond) NULL
[17:29:15.825]                   }
[17:29:15.825]                 })
[17:29:15.825]                 withCallingHandlers({
[17:29:15.825]                   {
[17:29:15.825]                     Sys.sleep(0.5)
[17:29:15.825]                     list(a = 1, b = 42L)
[17:29:15.825]                   }
[17:29:15.825]                 }, immediateCondition = function(cond) {
[17:29:15.825]                   sendCondition <- ...future.makeSendCondition()
[17:29:15.825]                   sendCondition(cond)
[17:29:15.825]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:15.825]                   {
[17:29:15.825]                     inherits <- base::inherits
[17:29:15.825]                     invokeRestart <- base::invokeRestart
[17:29:15.825]                     is.null <- base::is.null
[17:29:15.825]                     muffled <- FALSE
[17:29:15.825]                     if (inherits(cond, "message")) {
[17:29:15.825]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:15.825]                       if (muffled) 
[17:29:15.825]                         invokeRestart("muffleMessage")
[17:29:15.825]                     }
[17:29:15.825]                     else if (inherits(cond, "warning")) {
[17:29:15.825]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:15.825]                       if (muffled) 
[17:29:15.825]                         invokeRestart("muffleWarning")
[17:29:15.825]                     }
[17:29:15.825]                     else if (inherits(cond, "condition")) {
[17:29:15.825]                       if (!is.null(pattern)) {
[17:29:15.825]                         computeRestarts <- base::computeRestarts
[17:29:15.825]                         grepl <- base::grepl
[17:29:15.825]                         restarts <- computeRestarts(cond)
[17:29:15.825]                         for (restart in restarts) {
[17:29:15.825]                           name <- restart$name
[17:29:15.825]                           if (is.null(name)) 
[17:29:15.825]                             next
[17:29:15.825]                           if (!grepl(pattern, name)) 
[17:29:15.825]                             next
[17:29:15.825]                           invokeRestart(restart)
[17:29:15.825]                           muffled <- TRUE
[17:29:15.825]                           break
[17:29:15.825]                         }
[17:29:15.825]                       }
[17:29:15.825]                     }
[17:29:15.825]                     invisible(muffled)
[17:29:15.825]                   }
[17:29:15.825]                   muffleCondition(cond)
[17:29:15.825]                 })
[17:29:15.825]             }))
[17:29:15.825]             future::FutureResult(value = ...future.value$value, 
[17:29:15.825]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:15.825]                   ...future.rng), globalenv = if (FALSE) 
[17:29:15.825]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:15.825]                     ...future.globalenv.names))
[17:29:15.825]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:15.825]         }, condition = base::local({
[17:29:15.825]             c <- base::c
[17:29:15.825]             inherits <- base::inherits
[17:29:15.825]             invokeRestart <- base::invokeRestart
[17:29:15.825]             length <- base::length
[17:29:15.825]             list <- base::list
[17:29:15.825]             seq.int <- base::seq.int
[17:29:15.825]             signalCondition <- base::signalCondition
[17:29:15.825]             sys.calls <- base::sys.calls
[17:29:15.825]             `[[` <- base::`[[`
[17:29:15.825]             `+` <- base::`+`
[17:29:15.825]             `<<-` <- base::`<<-`
[17:29:15.825]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:15.825]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:15.825]                   3L)]
[17:29:15.825]             }
[17:29:15.825]             function(cond) {
[17:29:15.825]                 is_error <- inherits(cond, "error")
[17:29:15.825]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:15.825]                   NULL)
[17:29:15.825]                 if (is_error) {
[17:29:15.825]                   sessionInformation <- function() {
[17:29:15.825]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:15.825]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:15.825]                       search = base::search(), system = base::Sys.info())
[17:29:15.825]                   }
[17:29:15.825]                   ...future.conditions[[length(...future.conditions) + 
[17:29:15.825]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:15.825]                     cond$call), session = sessionInformation(), 
[17:29:15.825]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:15.825]                   signalCondition(cond)
[17:29:15.825]                 }
[17:29:15.825]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:15.825]                 "immediateCondition"))) {
[17:29:15.825]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:15.825]                   ...future.conditions[[length(...future.conditions) + 
[17:29:15.825]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:15.825]                   if (TRUE && !signal) {
[17:29:15.825]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:15.825]                     {
[17:29:15.825]                       inherits <- base::inherits
[17:29:15.825]                       invokeRestart <- base::invokeRestart
[17:29:15.825]                       is.null <- base::is.null
[17:29:15.825]                       muffled <- FALSE
[17:29:15.825]                       if (inherits(cond, "message")) {
[17:29:15.825]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:15.825]                         if (muffled) 
[17:29:15.825]                           invokeRestart("muffleMessage")
[17:29:15.825]                       }
[17:29:15.825]                       else if (inherits(cond, "warning")) {
[17:29:15.825]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:15.825]                         if (muffled) 
[17:29:15.825]                           invokeRestart("muffleWarning")
[17:29:15.825]                       }
[17:29:15.825]                       else if (inherits(cond, "condition")) {
[17:29:15.825]                         if (!is.null(pattern)) {
[17:29:15.825]                           computeRestarts <- base::computeRestarts
[17:29:15.825]                           grepl <- base::grepl
[17:29:15.825]                           restarts <- computeRestarts(cond)
[17:29:15.825]                           for (restart in restarts) {
[17:29:15.825]                             name <- restart$name
[17:29:15.825]                             if (is.null(name)) 
[17:29:15.825]                               next
[17:29:15.825]                             if (!grepl(pattern, name)) 
[17:29:15.825]                               next
[17:29:15.825]                             invokeRestart(restart)
[17:29:15.825]                             muffled <- TRUE
[17:29:15.825]                             break
[17:29:15.825]                           }
[17:29:15.825]                         }
[17:29:15.825]                       }
[17:29:15.825]                       invisible(muffled)
[17:29:15.825]                     }
[17:29:15.825]                     muffleCondition(cond, pattern = "^muffle")
[17:29:15.825]                   }
[17:29:15.825]                 }
[17:29:15.825]                 else {
[17:29:15.825]                   if (TRUE) {
[17:29:15.825]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:15.825]                     {
[17:29:15.825]                       inherits <- base::inherits
[17:29:15.825]                       invokeRestart <- base::invokeRestart
[17:29:15.825]                       is.null <- base::is.null
[17:29:15.825]                       muffled <- FALSE
[17:29:15.825]                       if (inherits(cond, "message")) {
[17:29:15.825]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:15.825]                         if (muffled) 
[17:29:15.825]                           invokeRestart("muffleMessage")
[17:29:15.825]                       }
[17:29:15.825]                       else if (inherits(cond, "warning")) {
[17:29:15.825]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:15.825]                         if (muffled) 
[17:29:15.825]                           invokeRestart("muffleWarning")
[17:29:15.825]                       }
[17:29:15.825]                       else if (inherits(cond, "condition")) {
[17:29:15.825]                         if (!is.null(pattern)) {
[17:29:15.825]                           computeRestarts <- base::computeRestarts
[17:29:15.825]                           grepl <- base::grepl
[17:29:15.825]                           restarts <- computeRestarts(cond)
[17:29:15.825]                           for (restart in restarts) {
[17:29:15.825]                             name <- restart$name
[17:29:15.825]                             if (is.null(name)) 
[17:29:15.825]                               next
[17:29:15.825]                             if (!grepl(pattern, name)) 
[17:29:15.825]                               next
[17:29:15.825]                             invokeRestart(restart)
[17:29:15.825]                             muffled <- TRUE
[17:29:15.825]                             break
[17:29:15.825]                           }
[17:29:15.825]                         }
[17:29:15.825]                       }
[17:29:15.825]                       invisible(muffled)
[17:29:15.825]                     }
[17:29:15.825]                     muffleCondition(cond, pattern = "^muffle")
[17:29:15.825]                   }
[17:29:15.825]                 }
[17:29:15.825]             }
[17:29:15.825]         }))
[17:29:15.825]     }, error = function(ex) {
[17:29:15.825]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:15.825]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:15.825]                 ...future.rng), started = ...future.startTime, 
[17:29:15.825]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:15.825]             version = "1.8"), class = "FutureResult")
[17:29:15.825]     }, finally = {
[17:29:15.825]         if (!identical(...future.workdir, getwd())) 
[17:29:15.825]             setwd(...future.workdir)
[17:29:15.825]         {
[17:29:15.825]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:15.825]                 ...future.oldOptions$nwarnings <- NULL
[17:29:15.825]             }
[17:29:15.825]             base::options(...future.oldOptions)
[17:29:15.825]             if (.Platform$OS.type == "windows") {
[17:29:15.825]                 old_names <- names(...future.oldEnvVars)
[17:29:15.825]                 envs <- base::Sys.getenv()
[17:29:15.825]                 names <- names(envs)
[17:29:15.825]                 common <- intersect(names, old_names)
[17:29:15.825]                 added <- setdiff(names, old_names)
[17:29:15.825]                 removed <- setdiff(old_names, names)
[17:29:15.825]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:15.825]                   envs[common]]
[17:29:15.825]                 NAMES <- toupper(changed)
[17:29:15.825]                 args <- list()
[17:29:15.825]                 for (kk in seq_along(NAMES)) {
[17:29:15.825]                   name <- changed[[kk]]
[17:29:15.825]                   NAME <- NAMES[[kk]]
[17:29:15.825]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:15.825]                     next
[17:29:15.825]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:15.825]                 }
[17:29:15.825]                 NAMES <- toupper(added)
[17:29:15.825]                 for (kk in seq_along(NAMES)) {
[17:29:15.825]                   name <- added[[kk]]
[17:29:15.825]                   NAME <- NAMES[[kk]]
[17:29:15.825]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:15.825]                     next
[17:29:15.825]                   args[[name]] <- ""
[17:29:15.825]                 }
[17:29:15.825]                 NAMES <- toupper(removed)
[17:29:15.825]                 for (kk in seq_along(NAMES)) {
[17:29:15.825]                   name <- removed[[kk]]
[17:29:15.825]                   NAME <- NAMES[[kk]]
[17:29:15.825]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:15.825]                     next
[17:29:15.825]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:15.825]                 }
[17:29:15.825]                 if (length(args) > 0) 
[17:29:15.825]                   base::do.call(base::Sys.setenv, args = args)
[17:29:15.825]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:15.825]             }
[17:29:15.825]             else {
[17:29:15.825]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:15.825]             }
[17:29:15.825]             {
[17:29:15.825]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:15.825]                   0L) {
[17:29:15.825]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:15.825]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:15.825]                   base::options(opts)
[17:29:15.825]                 }
[17:29:15.825]                 {
[17:29:15.825]                   {
[17:29:15.825]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:15.825]                     NULL
[17:29:15.825]                   }
[17:29:15.825]                   options(future.plan = NULL)
[17:29:15.825]                   if (is.na(NA_character_)) 
[17:29:15.825]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:15.825]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:15.825]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:15.825]                     .init = FALSE)
[17:29:15.825]                 }
[17:29:15.825]             }
[17:29:15.825]         }
[17:29:15.825]     })
[17:29:15.825]     if (TRUE) {
[17:29:15.825]         base::sink(type = "output", split = FALSE)
[17:29:15.825]         if (TRUE) {
[17:29:15.825]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:15.825]         }
[17:29:15.825]         else {
[17:29:15.825]             ...future.result["stdout"] <- base::list(NULL)
[17:29:15.825]         }
[17:29:15.825]         base::close(...future.stdout)
[17:29:15.825]         ...future.stdout <- NULL
[17:29:15.825]     }
[17:29:15.825]     ...future.result$conditions <- ...future.conditions
[17:29:15.825]     ...future.result$finished <- base::Sys.time()
[17:29:15.825]     ...future.result
[17:29:15.825] }
[17:29:15.835] MultisessionFuture started
[17:29:15.836] - Launch lazy future ... done
[17:29:15.836] run() for 'MultisessionFuture' ... done
[17:29:16.372] receiveMessageFromWorker() for ClusterFuture ...
[17:29:16.373] - Validating connection of MultisessionFuture
[17:29:16.373] - received message: FutureResult
[17:29:16.374] - Received FutureResult
[17:29:16.374] - Erased future from FutureRegistry
[17:29:16.374] result() for ClusterFuture ...
[17:29:16.375] - result already collected: FutureResult
[17:29:16.375] result() for ClusterFuture ... done
[17:29:16.375] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:16.376] A MultisessionFuture was resolved
[17:29:16.376] getGlobalsAndPackages() ...
[17:29:16.376] Searching for globals...
[17:29:16.379] - globals found: [3] '{', 'Sys.sleep', 'list'
[17:29:16.379] Searching for globals ... DONE
[17:29:16.379] Resolving globals: FALSE
[17:29:16.380] 
[17:29:16.380] 
[17:29:16.380] getGlobalsAndPackages() ... DONE
[17:29:16.381] run() for 'Future' ...
[17:29:16.381] - state: 'created'
[17:29:16.382] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:16.400] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:16.401] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:16.401]   - Field: 'node'
[17:29:16.401]   - Field: 'label'
[17:29:16.401]   - Field: 'local'
[17:29:16.401]   - Field: 'owner'
[17:29:16.402]   - Field: 'envir'
[17:29:16.402]   - Field: 'workers'
[17:29:16.402]   - Field: 'packages'
[17:29:16.402]   - Field: 'gc'
[17:29:16.402]   - Field: 'conditions'
[17:29:16.402]   - Field: 'persistent'
[17:29:16.403]   - Field: 'expr'
[17:29:16.403]   - Field: 'uuid'
[17:29:16.403]   - Field: 'seed'
[17:29:16.403]   - Field: 'version'
[17:29:16.403]   - Field: 'result'
[17:29:16.404]   - Field: 'asynchronous'
[17:29:16.404]   - Field: 'calls'
[17:29:16.404]   - Field: 'globals'
[17:29:16.404]   - Field: 'stdout'
[17:29:16.404]   - Field: 'earlySignal'
[17:29:16.405]   - Field: 'lazy'
[17:29:16.405]   - Field: 'state'
[17:29:16.405] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:16.405] - Launch lazy future ...
[17:29:16.406] Packages needed by the future expression (n = 0): <none>
[17:29:16.406] Packages needed by future strategies (n = 0): <none>
[17:29:16.407] {
[17:29:16.407]     {
[17:29:16.407]         {
[17:29:16.407]             ...future.startTime <- base::Sys.time()
[17:29:16.407]             {
[17:29:16.407]                 {
[17:29:16.407]                   {
[17:29:16.407]                     {
[17:29:16.407]                       base::local({
[17:29:16.407]                         has_future <- base::requireNamespace("future", 
[17:29:16.407]                           quietly = TRUE)
[17:29:16.407]                         if (has_future) {
[17:29:16.407]                           ns <- base::getNamespace("future")
[17:29:16.407]                           version <- ns[[".package"]][["version"]]
[17:29:16.407]                           if (is.null(version)) 
[17:29:16.407]                             version <- utils::packageVersion("future")
[17:29:16.407]                         }
[17:29:16.407]                         else {
[17:29:16.407]                           version <- NULL
[17:29:16.407]                         }
[17:29:16.407]                         if (!has_future || version < "1.8.0") {
[17:29:16.407]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:16.407]                             "", base::R.version$version.string), 
[17:29:16.407]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:16.407]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:16.407]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:16.407]                               "release", "version")], collapse = " "), 
[17:29:16.407]                             hostname = base::Sys.info()[["nodename"]])
[17:29:16.407]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:16.407]                             info)
[17:29:16.407]                           info <- base::paste(info, collapse = "; ")
[17:29:16.407]                           if (!has_future) {
[17:29:16.407]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:16.407]                               info)
[17:29:16.407]                           }
[17:29:16.407]                           else {
[17:29:16.407]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:16.407]                               info, version)
[17:29:16.407]                           }
[17:29:16.407]                           base::stop(msg)
[17:29:16.407]                         }
[17:29:16.407]                       })
[17:29:16.407]                     }
[17:29:16.407]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:16.407]                     base::options(mc.cores = 1L)
[17:29:16.407]                   }
[17:29:16.407]                   ...future.strategy.old <- future::plan("list")
[17:29:16.407]                   options(future.plan = NULL)
[17:29:16.407]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:16.407]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:16.407]                 }
[17:29:16.407]                 ...future.workdir <- getwd()
[17:29:16.407]             }
[17:29:16.407]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:16.407]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:16.407]         }
[17:29:16.407]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:16.407]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:16.407]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:16.407]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:16.407]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:16.407]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:16.407]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:16.407]             base::names(...future.oldOptions))
[17:29:16.407]     }
[17:29:16.407]     if (FALSE) {
[17:29:16.407]     }
[17:29:16.407]     else {
[17:29:16.407]         if (TRUE) {
[17:29:16.407]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:16.407]                 open = "w")
[17:29:16.407]         }
[17:29:16.407]         else {
[17:29:16.407]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:16.407]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:16.407]         }
[17:29:16.407]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:16.407]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:16.407]             base::sink(type = "output", split = FALSE)
[17:29:16.407]             base::close(...future.stdout)
[17:29:16.407]         }, add = TRUE)
[17:29:16.407]     }
[17:29:16.407]     ...future.frame <- base::sys.nframe()
[17:29:16.407]     ...future.conditions <- base::list()
[17:29:16.407]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:16.407]     if (FALSE) {
[17:29:16.407]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:16.407]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:16.407]     }
[17:29:16.407]     ...future.result <- base::tryCatch({
[17:29:16.407]         base::withCallingHandlers({
[17:29:16.407]             ...future.value <- base::withVisible(base::local({
[17:29:16.407]                 ...future.makeSendCondition <- base::local({
[17:29:16.407]                   sendCondition <- NULL
[17:29:16.407]                   function(frame = 1L) {
[17:29:16.407]                     if (is.function(sendCondition)) 
[17:29:16.407]                       return(sendCondition)
[17:29:16.407]                     ns <- getNamespace("parallel")
[17:29:16.407]                     if (exists("sendData", mode = "function", 
[17:29:16.407]                       envir = ns)) {
[17:29:16.407]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:16.407]                         envir = ns)
[17:29:16.407]                       envir <- sys.frame(frame)
[17:29:16.407]                       master <- NULL
[17:29:16.407]                       while (!identical(envir, .GlobalEnv) && 
[17:29:16.407]                         !identical(envir, emptyenv())) {
[17:29:16.407]                         if (exists("master", mode = "list", envir = envir, 
[17:29:16.407]                           inherits = FALSE)) {
[17:29:16.407]                           master <- get("master", mode = "list", 
[17:29:16.407]                             envir = envir, inherits = FALSE)
[17:29:16.407]                           if (inherits(master, c("SOCKnode", 
[17:29:16.407]                             "SOCK0node"))) {
[17:29:16.407]                             sendCondition <<- function(cond) {
[17:29:16.407]                               data <- list(type = "VALUE", value = cond, 
[17:29:16.407]                                 success = TRUE)
[17:29:16.407]                               parallel_sendData(master, data)
[17:29:16.407]                             }
[17:29:16.407]                             return(sendCondition)
[17:29:16.407]                           }
[17:29:16.407]                         }
[17:29:16.407]                         frame <- frame + 1L
[17:29:16.407]                         envir <- sys.frame(frame)
[17:29:16.407]                       }
[17:29:16.407]                     }
[17:29:16.407]                     sendCondition <<- function(cond) NULL
[17:29:16.407]                   }
[17:29:16.407]                 })
[17:29:16.407]                 withCallingHandlers({
[17:29:16.407]                   {
[17:29:16.407]                     Sys.sleep(0.5)
[17:29:16.407]                     list(a = 1, b = 42L)
[17:29:16.407]                   }
[17:29:16.407]                 }, immediateCondition = function(cond) {
[17:29:16.407]                   sendCondition <- ...future.makeSendCondition()
[17:29:16.407]                   sendCondition(cond)
[17:29:16.407]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:16.407]                   {
[17:29:16.407]                     inherits <- base::inherits
[17:29:16.407]                     invokeRestart <- base::invokeRestart
[17:29:16.407]                     is.null <- base::is.null
[17:29:16.407]                     muffled <- FALSE
[17:29:16.407]                     if (inherits(cond, "message")) {
[17:29:16.407]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:16.407]                       if (muffled) 
[17:29:16.407]                         invokeRestart("muffleMessage")
[17:29:16.407]                     }
[17:29:16.407]                     else if (inherits(cond, "warning")) {
[17:29:16.407]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:16.407]                       if (muffled) 
[17:29:16.407]                         invokeRestart("muffleWarning")
[17:29:16.407]                     }
[17:29:16.407]                     else if (inherits(cond, "condition")) {
[17:29:16.407]                       if (!is.null(pattern)) {
[17:29:16.407]                         computeRestarts <- base::computeRestarts
[17:29:16.407]                         grepl <- base::grepl
[17:29:16.407]                         restarts <- computeRestarts(cond)
[17:29:16.407]                         for (restart in restarts) {
[17:29:16.407]                           name <- restart$name
[17:29:16.407]                           if (is.null(name)) 
[17:29:16.407]                             next
[17:29:16.407]                           if (!grepl(pattern, name)) 
[17:29:16.407]                             next
[17:29:16.407]                           invokeRestart(restart)
[17:29:16.407]                           muffled <- TRUE
[17:29:16.407]                           break
[17:29:16.407]                         }
[17:29:16.407]                       }
[17:29:16.407]                     }
[17:29:16.407]                     invisible(muffled)
[17:29:16.407]                   }
[17:29:16.407]                   muffleCondition(cond)
[17:29:16.407]                 })
[17:29:16.407]             }))
[17:29:16.407]             future::FutureResult(value = ...future.value$value, 
[17:29:16.407]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:16.407]                   ...future.rng), globalenv = if (FALSE) 
[17:29:16.407]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:16.407]                     ...future.globalenv.names))
[17:29:16.407]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:16.407]         }, condition = base::local({
[17:29:16.407]             c <- base::c
[17:29:16.407]             inherits <- base::inherits
[17:29:16.407]             invokeRestart <- base::invokeRestart
[17:29:16.407]             length <- base::length
[17:29:16.407]             list <- base::list
[17:29:16.407]             seq.int <- base::seq.int
[17:29:16.407]             signalCondition <- base::signalCondition
[17:29:16.407]             sys.calls <- base::sys.calls
[17:29:16.407]             `[[` <- base::`[[`
[17:29:16.407]             `+` <- base::`+`
[17:29:16.407]             `<<-` <- base::`<<-`
[17:29:16.407]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:16.407]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:16.407]                   3L)]
[17:29:16.407]             }
[17:29:16.407]             function(cond) {
[17:29:16.407]                 is_error <- inherits(cond, "error")
[17:29:16.407]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:16.407]                   NULL)
[17:29:16.407]                 if (is_error) {
[17:29:16.407]                   sessionInformation <- function() {
[17:29:16.407]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:16.407]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:16.407]                       search = base::search(), system = base::Sys.info())
[17:29:16.407]                   }
[17:29:16.407]                   ...future.conditions[[length(...future.conditions) + 
[17:29:16.407]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:16.407]                     cond$call), session = sessionInformation(), 
[17:29:16.407]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:16.407]                   signalCondition(cond)
[17:29:16.407]                 }
[17:29:16.407]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:16.407]                 "immediateCondition"))) {
[17:29:16.407]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:16.407]                   ...future.conditions[[length(...future.conditions) + 
[17:29:16.407]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:16.407]                   if (TRUE && !signal) {
[17:29:16.407]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:16.407]                     {
[17:29:16.407]                       inherits <- base::inherits
[17:29:16.407]                       invokeRestart <- base::invokeRestart
[17:29:16.407]                       is.null <- base::is.null
[17:29:16.407]                       muffled <- FALSE
[17:29:16.407]                       if (inherits(cond, "message")) {
[17:29:16.407]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:16.407]                         if (muffled) 
[17:29:16.407]                           invokeRestart("muffleMessage")
[17:29:16.407]                       }
[17:29:16.407]                       else if (inherits(cond, "warning")) {
[17:29:16.407]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:16.407]                         if (muffled) 
[17:29:16.407]                           invokeRestart("muffleWarning")
[17:29:16.407]                       }
[17:29:16.407]                       else if (inherits(cond, "condition")) {
[17:29:16.407]                         if (!is.null(pattern)) {
[17:29:16.407]                           computeRestarts <- base::computeRestarts
[17:29:16.407]                           grepl <- base::grepl
[17:29:16.407]                           restarts <- computeRestarts(cond)
[17:29:16.407]                           for (restart in restarts) {
[17:29:16.407]                             name <- restart$name
[17:29:16.407]                             if (is.null(name)) 
[17:29:16.407]                               next
[17:29:16.407]                             if (!grepl(pattern, name)) 
[17:29:16.407]                               next
[17:29:16.407]                             invokeRestart(restart)
[17:29:16.407]                             muffled <- TRUE
[17:29:16.407]                             break
[17:29:16.407]                           }
[17:29:16.407]                         }
[17:29:16.407]                       }
[17:29:16.407]                       invisible(muffled)
[17:29:16.407]                     }
[17:29:16.407]                     muffleCondition(cond, pattern = "^muffle")
[17:29:16.407]                   }
[17:29:16.407]                 }
[17:29:16.407]                 else {
[17:29:16.407]                   if (TRUE) {
[17:29:16.407]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:16.407]                     {
[17:29:16.407]                       inherits <- base::inherits
[17:29:16.407]                       invokeRestart <- base::invokeRestart
[17:29:16.407]                       is.null <- base::is.null
[17:29:16.407]                       muffled <- FALSE
[17:29:16.407]                       if (inherits(cond, "message")) {
[17:29:16.407]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:16.407]                         if (muffled) 
[17:29:16.407]                           invokeRestart("muffleMessage")
[17:29:16.407]                       }
[17:29:16.407]                       else if (inherits(cond, "warning")) {
[17:29:16.407]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:16.407]                         if (muffled) 
[17:29:16.407]                           invokeRestart("muffleWarning")
[17:29:16.407]                       }
[17:29:16.407]                       else if (inherits(cond, "condition")) {
[17:29:16.407]                         if (!is.null(pattern)) {
[17:29:16.407]                           computeRestarts <- base::computeRestarts
[17:29:16.407]                           grepl <- base::grepl
[17:29:16.407]                           restarts <- computeRestarts(cond)
[17:29:16.407]                           for (restart in restarts) {
[17:29:16.407]                             name <- restart$name
[17:29:16.407]                             if (is.null(name)) 
[17:29:16.407]                               next
[17:29:16.407]                             if (!grepl(pattern, name)) 
[17:29:16.407]                               next
[17:29:16.407]                             invokeRestart(restart)
[17:29:16.407]                             muffled <- TRUE
[17:29:16.407]                             break
[17:29:16.407]                           }
[17:29:16.407]                         }
[17:29:16.407]                       }
[17:29:16.407]                       invisible(muffled)
[17:29:16.407]                     }
[17:29:16.407]                     muffleCondition(cond, pattern = "^muffle")
[17:29:16.407]                   }
[17:29:16.407]                 }
[17:29:16.407]             }
[17:29:16.407]         }))
[17:29:16.407]     }, error = function(ex) {
[17:29:16.407]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:16.407]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:16.407]                 ...future.rng), started = ...future.startTime, 
[17:29:16.407]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:16.407]             version = "1.8"), class = "FutureResult")
[17:29:16.407]     }, finally = {
[17:29:16.407]         if (!identical(...future.workdir, getwd())) 
[17:29:16.407]             setwd(...future.workdir)
[17:29:16.407]         {
[17:29:16.407]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:16.407]                 ...future.oldOptions$nwarnings <- NULL
[17:29:16.407]             }
[17:29:16.407]             base::options(...future.oldOptions)
[17:29:16.407]             if (.Platform$OS.type == "windows") {
[17:29:16.407]                 old_names <- names(...future.oldEnvVars)
[17:29:16.407]                 envs <- base::Sys.getenv()
[17:29:16.407]                 names <- names(envs)
[17:29:16.407]                 common <- intersect(names, old_names)
[17:29:16.407]                 added <- setdiff(names, old_names)
[17:29:16.407]                 removed <- setdiff(old_names, names)
[17:29:16.407]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:16.407]                   envs[common]]
[17:29:16.407]                 NAMES <- toupper(changed)
[17:29:16.407]                 args <- list()
[17:29:16.407]                 for (kk in seq_along(NAMES)) {
[17:29:16.407]                   name <- changed[[kk]]
[17:29:16.407]                   NAME <- NAMES[[kk]]
[17:29:16.407]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:16.407]                     next
[17:29:16.407]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:16.407]                 }
[17:29:16.407]                 NAMES <- toupper(added)
[17:29:16.407]                 for (kk in seq_along(NAMES)) {
[17:29:16.407]                   name <- added[[kk]]
[17:29:16.407]                   NAME <- NAMES[[kk]]
[17:29:16.407]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:16.407]                     next
[17:29:16.407]                   args[[name]] <- ""
[17:29:16.407]                 }
[17:29:16.407]                 NAMES <- toupper(removed)
[17:29:16.407]                 for (kk in seq_along(NAMES)) {
[17:29:16.407]                   name <- removed[[kk]]
[17:29:16.407]                   NAME <- NAMES[[kk]]
[17:29:16.407]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:16.407]                     next
[17:29:16.407]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:16.407]                 }
[17:29:16.407]                 if (length(args) > 0) 
[17:29:16.407]                   base::do.call(base::Sys.setenv, args = args)
[17:29:16.407]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:16.407]             }
[17:29:16.407]             else {
[17:29:16.407]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:16.407]             }
[17:29:16.407]             {
[17:29:16.407]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:16.407]                   0L) {
[17:29:16.407]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:16.407]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:16.407]                   base::options(opts)
[17:29:16.407]                 }
[17:29:16.407]                 {
[17:29:16.407]                   {
[17:29:16.407]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:16.407]                     NULL
[17:29:16.407]                   }
[17:29:16.407]                   options(future.plan = NULL)
[17:29:16.407]                   if (is.na(NA_character_)) 
[17:29:16.407]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:16.407]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:16.407]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:16.407]                     .init = FALSE)
[17:29:16.407]                 }
[17:29:16.407]             }
[17:29:16.407]         }
[17:29:16.407]     })
[17:29:16.407]     if (TRUE) {
[17:29:16.407]         base::sink(type = "output", split = FALSE)
[17:29:16.407]         if (TRUE) {
[17:29:16.407]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:16.407]         }
[17:29:16.407]         else {
[17:29:16.407]             ...future.result["stdout"] <- base::list(NULL)
[17:29:16.407]         }
[17:29:16.407]         base::close(...future.stdout)
[17:29:16.407]         ...future.stdout <- NULL
[17:29:16.407]     }
[17:29:16.407]     ...future.result$conditions <- ...future.conditions
[17:29:16.407]     ...future.result$finished <- base::Sys.time()
[17:29:16.407]     ...future.result
[17:29:16.407] }
[17:29:16.416] MultisessionFuture started
[17:29:16.416] - Launch lazy future ... done
[17:29:16.417] run() for 'MultisessionFuture' ... done
[17:29:16.951] receiveMessageFromWorker() for ClusterFuture ...
[17:29:16.951] - Validating connection of MultisessionFuture
[17:29:16.952] - received message: FutureResult
[17:29:16.952] - Received FutureResult
[17:29:16.953] - Erased future from FutureRegistry
[17:29:16.953] result() for ClusterFuture ...
[17:29:16.953] - result already collected: FutureResult
[17:29:16.954] result() for ClusterFuture ... done
[17:29:16.954] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:16.954] A MultisessionFuture was resolved
- w/ exception ...
[17:29:16.955] getGlobalsAndPackages() ...
[17:29:16.955] Searching for globals...
[17:29:16.957] - globals found: [2] 'list', 'stop'
[17:29:16.958] Searching for globals ... DONE
[17:29:16.958] Resolving globals: FALSE
[17:29:16.959] 
[17:29:16.959] 
[17:29:16.959] getGlobalsAndPackages() ... DONE
[17:29:16.960] run() for 'Future' ...
[17:29:16.960] - state: 'created'
[17:29:16.961] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:16.981] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:16.981] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:16.982]   - Field: 'node'
[17:29:16.982]   - Field: 'label'
[17:29:16.982]   - Field: 'local'
[17:29:16.983]   - Field: 'owner'
[17:29:16.983]   - Field: 'envir'
[17:29:16.983]   - Field: 'workers'
[17:29:16.984]   - Field: 'packages'
[17:29:16.984]   - Field: 'gc'
[17:29:16.984]   - Field: 'conditions'
[17:29:16.984]   - Field: 'persistent'
[17:29:16.985]   - Field: 'expr'
[17:29:16.985]   - Field: 'uuid'
[17:29:16.985]   - Field: 'seed'
[17:29:16.986]   - Field: 'version'
[17:29:16.986]   - Field: 'result'
[17:29:16.986]   - Field: 'asynchronous'
[17:29:16.986]   - Field: 'calls'
[17:29:16.987]   - Field: 'globals'
[17:29:16.987]   - Field: 'stdout'
[17:29:16.987]   - Field: 'earlySignal'
[17:29:16.987]   - Field: 'lazy'
[17:29:16.988]   - Field: 'state'
[17:29:16.988] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:16.989] - Launch lazy future ...
[17:29:16.989] Packages needed by the future expression (n = 0): <none>
[17:29:16.990] Packages needed by future strategies (n = 0): <none>
[17:29:16.991] {
[17:29:16.991]     {
[17:29:16.991]         {
[17:29:16.991]             ...future.startTime <- base::Sys.time()
[17:29:16.991]             {
[17:29:16.991]                 {
[17:29:16.991]                   {
[17:29:16.991]                     {
[17:29:16.991]                       base::local({
[17:29:16.991]                         has_future <- base::requireNamespace("future", 
[17:29:16.991]                           quietly = TRUE)
[17:29:16.991]                         if (has_future) {
[17:29:16.991]                           ns <- base::getNamespace("future")
[17:29:16.991]                           version <- ns[[".package"]][["version"]]
[17:29:16.991]                           if (is.null(version)) 
[17:29:16.991]                             version <- utils::packageVersion("future")
[17:29:16.991]                         }
[17:29:16.991]                         else {
[17:29:16.991]                           version <- NULL
[17:29:16.991]                         }
[17:29:16.991]                         if (!has_future || version < "1.8.0") {
[17:29:16.991]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:16.991]                             "", base::R.version$version.string), 
[17:29:16.991]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:16.991]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:16.991]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:16.991]                               "release", "version")], collapse = " "), 
[17:29:16.991]                             hostname = base::Sys.info()[["nodename"]])
[17:29:16.991]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:16.991]                             info)
[17:29:16.991]                           info <- base::paste(info, collapse = "; ")
[17:29:16.991]                           if (!has_future) {
[17:29:16.991]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:16.991]                               info)
[17:29:16.991]                           }
[17:29:16.991]                           else {
[17:29:16.991]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:16.991]                               info, version)
[17:29:16.991]                           }
[17:29:16.991]                           base::stop(msg)
[17:29:16.991]                         }
[17:29:16.991]                       })
[17:29:16.991]                     }
[17:29:16.991]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:16.991]                     base::options(mc.cores = 1L)
[17:29:16.991]                   }
[17:29:16.991]                   ...future.strategy.old <- future::plan("list")
[17:29:16.991]                   options(future.plan = NULL)
[17:29:16.991]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:16.991]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:16.991]                 }
[17:29:16.991]                 ...future.workdir <- getwd()
[17:29:16.991]             }
[17:29:16.991]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:16.991]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:16.991]         }
[17:29:16.991]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:16.991]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:16.991]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:16.991]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:16.991]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:16.991]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:16.991]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:16.991]             base::names(...future.oldOptions))
[17:29:16.991]     }
[17:29:16.991]     if (FALSE) {
[17:29:16.991]     }
[17:29:16.991]     else {
[17:29:16.991]         if (TRUE) {
[17:29:16.991]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:16.991]                 open = "w")
[17:29:16.991]         }
[17:29:16.991]         else {
[17:29:16.991]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:16.991]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:16.991]         }
[17:29:16.991]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:16.991]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:16.991]             base::sink(type = "output", split = FALSE)
[17:29:16.991]             base::close(...future.stdout)
[17:29:16.991]         }, add = TRUE)
[17:29:16.991]     }
[17:29:16.991]     ...future.frame <- base::sys.nframe()
[17:29:16.991]     ...future.conditions <- base::list()
[17:29:16.991]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:16.991]     if (FALSE) {
[17:29:16.991]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:16.991]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:16.991]     }
[17:29:16.991]     ...future.result <- base::tryCatch({
[17:29:16.991]         base::withCallingHandlers({
[17:29:16.991]             ...future.value <- base::withVisible(base::local({
[17:29:16.991]                 ...future.makeSendCondition <- base::local({
[17:29:16.991]                   sendCondition <- NULL
[17:29:16.991]                   function(frame = 1L) {
[17:29:16.991]                     if (is.function(sendCondition)) 
[17:29:16.991]                       return(sendCondition)
[17:29:16.991]                     ns <- getNamespace("parallel")
[17:29:16.991]                     if (exists("sendData", mode = "function", 
[17:29:16.991]                       envir = ns)) {
[17:29:16.991]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:16.991]                         envir = ns)
[17:29:16.991]                       envir <- sys.frame(frame)
[17:29:16.991]                       master <- NULL
[17:29:16.991]                       while (!identical(envir, .GlobalEnv) && 
[17:29:16.991]                         !identical(envir, emptyenv())) {
[17:29:16.991]                         if (exists("master", mode = "list", envir = envir, 
[17:29:16.991]                           inherits = FALSE)) {
[17:29:16.991]                           master <- get("master", mode = "list", 
[17:29:16.991]                             envir = envir, inherits = FALSE)
[17:29:16.991]                           if (inherits(master, c("SOCKnode", 
[17:29:16.991]                             "SOCK0node"))) {
[17:29:16.991]                             sendCondition <<- function(cond) {
[17:29:16.991]                               data <- list(type = "VALUE", value = cond, 
[17:29:16.991]                                 success = TRUE)
[17:29:16.991]                               parallel_sendData(master, data)
[17:29:16.991]                             }
[17:29:16.991]                             return(sendCondition)
[17:29:16.991]                           }
[17:29:16.991]                         }
[17:29:16.991]                         frame <- frame + 1L
[17:29:16.991]                         envir <- sys.frame(frame)
[17:29:16.991]                       }
[17:29:16.991]                     }
[17:29:16.991]                     sendCondition <<- function(cond) NULL
[17:29:16.991]                   }
[17:29:16.991]                 })
[17:29:16.991]                 withCallingHandlers({
[17:29:16.991]                   list(a = 1, b = 42L, c = stop("Nah!"))
[17:29:16.991]                 }, immediateCondition = function(cond) {
[17:29:16.991]                   sendCondition <- ...future.makeSendCondition()
[17:29:16.991]                   sendCondition(cond)
[17:29:16.991]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:16.991]                   {
[17:29:16.991]                     inherits <- base::inherits
[17:29:16.991]                     invokeRestart <- base::invokeRestart
[17:29:16.991]                     is.null <- base::is.null
[17:29:16.991]                     muffled <- FALSE
[17:29:16.991]                     if (inherits(cond, "message")) {
[17:29:16.991]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:16.991]                       if (muffled) 
[17:29:16.991]                         invokeRestart("muffleMessage")
[17:29:16.991]                     }
[17:29:16.991]                     else if (inherits(cond, "warning")) {
[17:29:16.991]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:16.991]                       if (muffled) 
[17:29:16.991]                         invokeRestart("muffleWarning")
[17:29:16.991]                     }
[17:29:16.991]                     else if (inherits(cond, "condition")) {
[17:29:16.991]                       if (!is.null(pattern)) {
[17:29:16.991]                         computeRestarts <- base::computeRestarts
[17:29:16.991]                         grepl <- base::grepl
[17:29:16.991]                         restarts <- computeRestarts(cond)
[17:29:16.991]                         for (restart in restarts) {
[17:29:16.991]                           name <- restart$name
[17:29:16.991]                           if (is.null(name)) 
[17:29:16.991]                             next
[17:29:16.991]                           if (!grepl(pattern, name)) 
[17:29:16.991]                             next
[17:29:16.991]                           invokeRestart(restart)
[17:29:16.991]                           muffled <- TRUE
[17:29:16.991]                           break
[17:29:16.991]                         }
[17:29:16.991]                       }
[17:29:16.991]                     }
[17:29:16.991]                     invisible(muffled)
[17:29:16.991]                   }
[17:29:16.991]                   muffleCondition(cond)
[17:29:16.991]                 })
[17:29:16.991]             }))
[17:29:16.991]             future::FutureResult(value = ...future.value$value, 
[17:29:16.991]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:16.991]                   ...future.rng), globalenv = if (FALSE) 
[17:29:16.991]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:16.991]                     ...future.globalenv.names))
[17:29:16.991]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:16.991]         }, condition = base::local({
[17:29:16.991]             c <- base::c
[17:29:16.991]             inherits <- base::inherits
[17:29:16.991]             invokeRestart <- base::invokeRestart
[17:29:16.991]             length <- base::length
[17:29:16.991]             list <- base::list
[17:29:16.991]             seq.int <- base::seq.int
[17:29:16.991]             signalCondition <- base::signalCondition
[17:29:16.991]             sys.calls <- base::sys.calls
[17:29:16.991]             `[[` <- base::`[[`
[17:29:16.991]             `+` <- base::`+`
[17:29:16.991]             `<<-` <- base::`<<-`
[17:29:16.991]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:16.991]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:16.991]                   3L)]
[17:29:16.991]             }
[17:29:16.991]             function(cond) {
[17:29:16.991]                 is_error <- inherits(cond, "error")
[17:29:16.991]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:16.991]                   NULL)
[17:29:16.991]                 if (is_error) {
[17:29:16.991]                   sessionInformation <- function() {
[17:29:16.991]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:16.991]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:16.991]                       search = base::search(), system = base::Sys.info())
[17:29:16.991]                   }
[17:29:16.991]                   ...future.conditions[[length(...future.conditions) + 
[17:29:16.991]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:16.991]                     cond$call), session = sessionInformation(), 
[17:29:16.991]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:16.991]                   signalCondition(cond)
[17:29:16.991]                 }
[17:29:16.991]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:16.991]                 "immediateCondition"))) {
[17:29:16.991]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:16.991]                   ...future.conditions[[length(...future.conditions) + 
[17:29:16.991]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:16.991]                   if (TRUE && !signal) {
[17:29:16.991]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:16.991]                     {
[17:29:16.991]                       inherits <- base::inherits
[17:29:16.991]                       invokeRestart <- base::invokeRestart
[17:29:16.991]                       is.null <- base::is.null
[17:29:16.991]                       muffled <- FALSE
[17:29:16.991]                       if (inherits(cond, "message")) {
[17:29:16.991]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:16.991]                         if (muffled) 
[17:29:16.991]                           invokeRestart("muffleMessage")
[17:29:16.991]                       }
[17:29:16.991]                       else if (inherits(cond, "warning")) {
[17:29:16.991]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:16.991]                         if (muffled) 
[17:29:16.991]                           invokeRestart("muffleWarning")
[17:29:16.991]                       }
[17:29:16.991]                       else if (inherits(cond, "condition")) {
[17:29:16.991]                         if (!is.null(pattern)) {
[17:29:16.991]                           computeRestarts <- base::computeRestarts
[17:29:16.991]                           grepl <- base::grepl
[17:29:16.991]                           restarts <- computeRestarts(cond)
[17:29:16.991]                           for (restart in restarts) {
[17:29:16.991]                             name <- restart$name
[17:29:16.991]                             if (is.null(name)) 
[17:29:16.991]                               next
[17:29:16.991]                             if (!grepl(pattern, name)) 
[17:29:16.991]                               next
[17:29:16.991]                             invokeRestart(restart)
[17:29:16.991]                             muffled <- TRUE
[17:29:16.991]                             break
[17:29:16.991]                           }
[17:29:16.991]                         }
[17:29:16.991]                       }
[17:29:16.991]                       invisible(muffled)
[17:29:16.991]                     }
[17:29:16.991]                     muffleCondition(cond, pattern = "^muffle")
[17:29:16.991]                   }
[17:29:16.991]                 }
[17:29:16.991]                 else {
[17:29:16.991]                   if (TRUE) {
[17:29:16.991]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:16.991]                     {
[17:29:16.991]                       inherits <- base::inherits
[17:29:16.991]                       invokeRestart <- base::invokeRestart
[17:29:16.991]                       is.null <- base::is.null
[17:29:16.991]                       muffled <- FALSE
[17:29:16.991]                       if (inherits(cond, "message")) {
[17:29:16.991]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:16.991]                         if (muffled) 
[17:29:16.991]                           invokeRestart("muffleMessage")
[17:29:16.991]                       }
[17:29:16.991]                       else if (inherits(cond, "warning")) {
[17:29:16.991]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:16.991]                         if (muffled) 
[17:29:16.991]                           invokeRestart("muffleWarning")
[17:29:16.991]                       }
[17:29:16.991]                       else if (inherits(cond, "condition")) {
[17:29:16.991]                         if (!is.null(pattern)) {
[17:29:16.991]                           computeRestarts <- base::computeRestarts
[17:29:16.991]                           grepl <- base::grepl
[17:29:16.991]                           restarts <- computeRestarts(cond)
[17:29:16.991]                           for (restart in restarts) {
[17:29:16.991]                             name <- restart$name
[17:29:16.991]                             if (is.null(name)) 
[17:29:16.991]                               next
[17:29:16.991]                             if (!grepl(pattern, name)) 
[17:29:16.991]                               next
[17:29:16.991]                             invokeRestart(restart)
[17:29:16.991]                             muffled <- TRUE
[17:29:16.991]                             break
[17:29:16.991]                           }
[17:29:16.991]                         }
[17:29:16.991]                       }
[17:29:16.991]                       invisible(muffled)
[17:29:16.991]                     }
[17:29:16.991]                     muffleCondition(cond, pattern = "^muffle")
[17:29:16.991]                   }
[17:29:16.991]                 }
[17:29:16.991]             }
[17:29:16.991]         }))
[17:29:16.991]     }, error = function(ex) {
[17:29:16.991]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:16.991]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:16.991]                 ...future.rng), started = ...future.startTime, 
[17:29:16.991]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:16.991]             version = "1.8"), class = "FutureResult")
[17:29:16.991]     }, finally = {
[17:29:16.991]         if (!identical(...future.workdir, getwd())) 
[17:29:16.991]             setwd(...future.workdir)
[17:29:16.991]         {
[17:29:16.991]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:16.991]                 ...future.oldOptions$nwarnings <- NULL
[17:29:16.991]             }
[17:29:16.991]             base::options(...future.oldOptions)
[17:29:16.991]             if (.Platform$OS.type == "windows") {
[17:29:16.991]                 old_names <- names(...future.oldEnvVars)
[17:29:16.991]                 envs <- base::Sys.getenv()
[17:29:16.991]                 names <- names(envs)
[17:29:16.991]                 common <- intersect(names, old_names)
[17:29:16.991]                 added <- setdiff(names, old_names)
[17:29:16.991]                 removed <- setdiff(old_names, names)
[17:29:16.991]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:16.991]                   envs[common]]
[17:29:16.991]                 NAMES <- toupper(changed)
[17:29:16.991]                 args <- list()
[17:29:16.991]                 for (kk in seq_along(NAMES)) {
[17:29:16.991]                   name <- changed[[kk]]
[17:29:16.991]                   NAME <- NAMES[[kk]]
[17:29:16.991]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:16.991]                     next
[17:29:16.991]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:16.991]                 }
[17:29:16.991]                 NAMES <- toupper(added)
[17:29:16.991]                 for (kk in seq_along(NAMES)) {
[17:29:16.991]                   name <- added[[kk]]
[17:29:16.991]                   NAME <- NAMES[[kk]]
[17:29:16.991]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:16.991]                     next
[17:29:16.991]                   args[[name]] <- ""
[17:29:16.991]                 }
[17:29:16.991]                 NAMES <- toupper(removed)
[17:29:16.991]                 for (kk in seq_along(NAMES)) {
[17:29:16.991]                   name <- removed[[kk]]
[17:29:16.991]                   NAME <- NAMES[[kk]]
[17:29:16.991]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:16.991]                     next
[17:29:16.991]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:16.991]                 }
[17:29:16.991]                 if (length(args) > 0) 
[17:29:16.991]                   base::do.call(base::Sys.setenv, args = args)
[17:29:16.991]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:16.991]             }
[17:29:16.991]             else {
[17:29:16.991]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:16.991]             }
[17:29:16.991]             {
[17:29:16.991]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:16.991]                   0L) {
[17:29:16.991]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:16.991]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:16.991]                   base::options(opts)
[17:29:16.991]                 }
[17:29:16.991]                 {
[17:29:16.991]                   {
[17:29:16.991]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:16.991]                     NULL
[17:29:16.991]                   }
[17:29:16.991]                   options(future.plan = NULL)
[17:29:16.991]                   if (is.na(NA_character_)) 
[17:29:16.991]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:16.991]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:16.991]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:16.991]                     .init = FALSE)
[17:29:16.991]                 }
[17:29:16.991]             }
[17:29:16.991]         }
[17:29:16.991]     })
[17:29:16.991]     if (TRUE) {
[17:29:16.991]         base::sink(type = "output", split = FALSE)
[17:29:16.991]         if (TRUE) {
[17:29:16.991]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:16.991]         }
[17:29:16.991]         else {
[17:29:16.991]             ...future.result["stdout"] <- base::list(NULL)
[17:29:16.991]         }
[17:29:16.991]         base::close(...future.stdout)
[17:29:16.991]         ...future.stdout <- NULL
[17:29:16.991]     }
[17:29:16.991]     ...future.result$conditions <- ...future.conditions
[17:29:16.991]     ...future.result$finished <- base::Sys.time()
[17:29:16.991]     ...future.result
[17:29:16.991] }
[17:29:17.002] MultisessionFuture started
[17:29:17.002] - Launch lazy future ... done
[17:29:17.003] run() for 'MultisessionFuture' ... done
[17:29:17.027] receiveMessageFromWorker() for ClusterFuture ...
[17:29:17.028] - Validating connection of MultisessionFuture
[17:29:17.029] - received message: FutureResult
[17:29:17.029] - Received FutureResult
[17:29:17.029] - Erased future from FutureRegistry
[17:29:17.030] result() for ClusterFuture ...
[17:29:17.030] - result already collected: FutureResult
[17:29:17.030] result() for ClusterFuture ... done
[17:29:17.030] signalConditions() ...
[17:29:17.030]  - include = 'immediateCondition'
[17:29:17.031]  - exclude = 
[17:29:17.031]  - resignal = FALSE
[17:29:17.031]  - Number of conditions: 1
[17:29:17.032] signalConditions() ... done
[17:29:17.032] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:17.032] A MultisessionFuture was resolved
[17:29:17.033] getGlobalsAndPackages() ...
[17:29:17.033] Searching for globals...
[17:29:17.035] - globals found: [2] 'list', 'stop'
[17:29:17.035] Searching for globals ... DONE
[17:29:17.036] Resolving globals: FALSE
[17:29:17.036] 
[17:29:17.037] 
[17:29:17.037] getGlobalsAndPackages() ... DONE
[17:29:17.038] run() for 'Future' ...
[17:29:17.038] - state: 'created'
[17:29:17.039] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:17.062] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:17.067] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:17.067]   - Field: 'node'
[17:29:17.067]   - Field: 'label'
[17:29:17.067]   - Field: 'local'
[17:29:17.067]   - Field: 'owner'
[17:29:17.068]   - Field: 'envir'
[17:29:17.068]   - Field: 'workers'
[17:29:17.068]   - Field: 'packages'
[17:29:17.068]   - Field: 'gc'
[17:29:17.068]   - Field: 'conditions'
[17:29:17.069]   - Field: 'persistent'
[17:29:17.069]   - Field: 'expr'
[17:29:17.069]   - Field: 'uuid'
[17:29:17.069]   - Field: 'seed'
[17:29:17.069]   - Field: 'version'
[17:29:17.069]   - Field: 'result'
[17:29:17.070]   - Field: 'asynchronous'
[17:29:17.070]   - Field: 'calls'
[17:29:17.070]   - Field: 'globals'
[17:29:17.070]   - Field: 'stdout'
[17:29:17.070]   - Field: 'earlySignal'
[17:29:17.070]   - Field: 'lazy'
[17:29:17.071]   - Field: 'state'
[17:29:17.071] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:17.071] - Launch lazy future ...
[17:29:17.071] Packages needed by the future expression (n = 0): <none>
[17:29:17.072] Packages needed by future strategies (n = 0): <none>
[17:29:17.072] {
[17:29:17.072]     {
[17:29:17.072]         {
[17:29:17.072]             ...future.startTime <- base::Sys.time()
[17:29:17.072]             {
[17:29:17.072]                 {
[17:29:17.072]                   {
[17:29:17.072]                     {
[17:29:17.072]                       base::local({
[17:29:17.072]                         has_future <- base::requireNamespace("future", 
[17:29:17.072]                           quietly = TRUE)
[17:29:17.072]                         if (has_future) {
[17:29:17.072]                           ns <- base::getNamespace("future")
[17:29:17.072]                           version <- ns[[".package"]][["version"]]
[17:29:17.072]                           if (is.null(version)) 
[17:29:17.072]                             version <- utils::packageVersion("future")
[17:29:17.072]                         }
[17:29:17.072]                         else {
[17:29:17.072]                           version <- NULL
[17:29:17.072]                         }
[17:29:17.072]                         if (!has_future || version < "1.8.0") {
[17:29:17.072]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:17.072]                             "", base::R.version$version.string), 
[17:29:17.072]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:17.072]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:17.072]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:17.072]                               "release", "version")], collapse = " "), 
[17:29:17.072]                             hostname = base::Sys.info()[["nodename"]])
[17:29:17.072]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:17.072]                             info)
[17:29:17.072]                           info <- base::paste(info, collapse = "; ")
[17:29:17.072]                           if (!has_future) {
[17:29:17.072]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:17.072]                               info)
[17:29:17.072]                           }
[17:29:17.072]                           else {
[17:29:17.072]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:17.072]                               info, version)
[17:29:17.072]                           }
[17:29:17.072]                           base::stop(msg)
[17:29:17.072]                         }
[17:29:17.072]                       })
[17:29:17.072]                     }
[17:29:17.072]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:17.072]                     base::options(mc.cores = 1L)
[17:29:17.072]                   }
[17:29:17.072]                   ...future.strategy.old <- future::plan("list")
[17:29:17.072]                   options(future.plan = NULL)
[17:29:17.072]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:17.072]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:17.072]                 }
[17:29:17.072]                 ...future.workdir <- getwd()
[17:29:17.072]             }
[17:29:17.072]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:17.072]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:17.072]         }
[17:29:17.072]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:17.072]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:17.072]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:17.072]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:17.072]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:17.072]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:17.072]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:17.072]             base::names(...future.oldOptions))
[17:29:17.072]     }
[17:29:17.072]     if (FALSE) {
[17:29:17.072]     }
[17:29:17.072]     else {
[17:29:17.072]         if (TRUE) {
[17:29:17.072]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:17.072]                 open = "w")
[17:29:17.072]         }
[17:29:17.072]         else {
[17:29:17.072]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:17.072]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:17.072]         }
[17:29:17.072]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:17.072]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:17.072]             base::sink(type = "output", split = FALSE)
[17:29:17.072]             base::close(...future.stdout)
[17:29:17.072]         }, add = TRUE)
[17:29:17.072]     }
[17:29:17.072]     ...future.frame <- base::sys.nframe()
[17:29:17.072]     ...future.conditions <- base::list()
[17:29:17.072]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:17.072]     if (FALSE) {
[17:29:17.072]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:17.072]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:17.072]     }
[17:29:17.072]     ...future.result <- base::tryCatch({
[17:29:17.072]         base::withCallingHandlers({
[17:29:17.072]             ...future.value <- base::withVisible(base::local({
[17:29:17.072]                 ...future.makeSendCondition <- base::local({
[17:29:17.072]                   sendCondition <- NULL
[17:29:17.072]                   function(frame = 1L) {
[17:29:17.072]                     if (is.function(sendCondition)) 
[17:29:17.072]                       return(sendCondition)
[17:29:17.072]                     ns <- getNamespace("parallel")
[17:29:17.072]                     if (exists("sendData", mode = "function", 
[17:29:17.072]                       envir = ns)) {
[17:29:17.072]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:17.072]                         envir = ns)
[17:29:17.072]                       envir <- sys.frame(frame)
[17:29:17.072]                       master <- NULL
[17:29:17.072]                       while (!identical(envir, .GlobalEnv) && 
[17:29:17.072]                         !identical(envir, emptyenv())) {
[17:29:17.072]                         if (exists("master", mode = "list", envir = envir, 
[17:29:17.072]                           inherits = FALSE)) {
[17:29:17.072]                           master <- get("master", mode = "list", 
[17:29:17.072]                             envir = envir, inherits = FALSE)
[17:29:17.072]                           if (inherits(master, c("SOCKnode", 
[17:29:17.072]                             "SOCK0node"))) {
[17:29:17.072]                             sendCondition <<- function(cond) {
[17:29:17.072]                               data <- list(type = "VALUE", value = cond, 
[17:29:17.072]                                 success = TRUE)
[17:29:17.072]                               parallel_sendData(master, data)
[17:29:17.072]                             }
[17:29:17.072]                             return(sendCondition)
[17:29:17.072]                           }
[17:29:17.072]                         }
[17:29:17.072]                         frame <- frame + 1L
[17:29:17.072]                         envir <- sys.frame(frame)
[17:29:17.072]                       }
[17:29:17.072]                     }
[17:29:17.072]                     sendCondition <<- function(cond) NULL
[17:29:17.072]                   }
[17:29:17.072]                 })
[17:29:17.072]                 withCallingHandlers({
[17:29:17.072]                   list(a = 1, b = 42L, c = stop("Nah!"))
[17:29:17.072]                 }, immediateCondition = function(cond) {
[17:29:17.072]                   sendCondition <- ...future.makeSendCondition()
[17:29:17.072]                   sendCondition(cond)
[17:29:17.072]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:17.072]                   {
[17:29:17.072]                     inherits <- base::inherits
[17:29:17.072]                     invokeRestart <- base::invokeRestart
[17:29:17.072]                     is.null <- base::is.null
[17:29:17.072]                     muffled <- FALSE
[17:29:17.072]                     if (inherits(cond, "message")) {
[17:29:17.072]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:17.072]                       if (muffled) 
[17:29:17.072]                         invokeRestart("muffleMessage")
[17:29:17.072]                     }
[17:29:17.072]                     else if (inherits(cond, "warning")) {
[17:29:17.072]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:17.072]                       if (muffled) 
[17:29:17.072]                         invokeRestart("muffleWarning")
[17:29:17.072]                     }
[17:29:17.072]                     else if (inherits(cond, "condition")) {
[17:29:17.072]                       if (!is.null(pattern)) {
[17:29:17.072]                         computeRestarts <- base::computeRestarts
[17:29:17.072]                         grepl <- base::grepl
[17:29:17.072]                         restarts <- computeRestarts(cond)
[17:29:17.072]                         for (restart in restarts) {
[17:29:17.072]                           name <- restart$name
[17:29:17.072]                           if (is.null(name)) 
[17:29:17.072]                             next
[17:29:17.072]                           if (!grepl(pattern, name)) 
[17:29:17.072]                             next
[17:29:17.072]                           invokeRestart(restart)
[17:29:17.072]                           muffled <- TRUE
[17:29:17.072]                           break
[17:29:17.072]                         }
[17:29:17.072]                       }
[17:29:17.072]                     }
[17:29:17.072]                     invisible(muffled)
[17:29:17.072]                   }
[17:29:17.072]                   muffleCondition(cond)
[17:29:17.072]                 })
[17:29:17.072]             }))
[17:29:17.072]             future::FutureResult(value = ...future.value$value, 
[17:29:17.072]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:17.072]                   ...future.rng), globalenv = if (FALSE) 
[17:29:17.072]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:17.072]                     ...future.globalenv.names))
[17:29:17.072]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:17.072]         }, condition = base::local({
[17:29:17.072]             c <- base::c
[17:29:17.072]             inherits <- base::inherits
[17:29:17.072]             invokeRestart <- base::invokeRestart
[17:29:17.072]             length <- base::length
[17:29:17.072]             list <- base::list
[17:29:17.072]             seq.int <- base::seq.int
[17:29:17.072]             signalCondition <- base::signalCondition
[17:29:17.072]             sys.calls <- base::sys.calls
[17:29:17.072]             `[[` <- base::`[[`
[17:29:17.072]             `+` <- base::`+`
[17:29:17.072]             `<<-` <- base::`<<-`
[17:29:17.072]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:17.072]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:17.072]                   3L)]
[17:29:17.072]             }
[17:29:17.072]             function(cond) {
[17:29:17.072]                 is_error <- inherits(cond, "error")
[17:29:17.072]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:17.072]                   NULL)
[17:29:17.072]                 if (is_error) {
[17:29:17.072]                   sessionInformation <- function() {
[17:29:17.072]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:17.072]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:17.072]                       search = base::search(), system = base::Sys.info())
[17:29:17.072]                   }
[17:29:17.072]                   ...future.conditions[[length(...future.conditions) + 
[17:29:17.072]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:17.072]                     cond$call), session = sessionInformation(), 
[17:29:17.072]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:17.072]                   signalCondition(cond)
[17:29:17.072]                 }
[17:29:17.072]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:17.072]                 "immediateCondition"))) {
[17:29:17.072]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:17.072]                   ...future.conditions[[length(...future.conditions) + 
[17:29:17.072]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:17.072]                   if (TRUE && !signal) {
[17:29:17.072]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:17.072]                     {
[17:29:17.072]                       inherits <- base::inherits
[17:29:17.072]                       invokeRestart <- base::invokeRestart
[17:29:17.072]                       is.null <- base::is.null
[17:29:17.072]                       muffled <- FALSE
[17:29:17.072]                       if (inherits(cond, "message")) {
[17:29:17.072]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:17.072]                         if (muffled) 
[17:29:17.072]                           invokeRestart("muffleMessage")
[17:29:17.072]                       }
[17:29:17.072]                       else if (inherits(cond, "warning")) {
[17:29:17.072]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:17.072]                         if (muffled) 
[17:29:17.072]                           invokeRestart("muffleWarning")
[17:29:17.072]                       }
[17:29:17.072]                       else if (inherits(cond, "condition")) {
[17:29:17.072]                         if (!is.null(pattern)) {
[17:29:17.072]                           computeRestarts <- base::computeRestarts
[17:29:17.072]                           grepl <- base::grepl
[17:29:17.072]                           restarts <- computeRestarts(cond)
[17:29:17.072]                           for (restart in restarts) {
[17:29:17.072]                             name <- restart$name
[17:29:17.072]                             if (is.null(name)) 
[17:29:17.072]                               next
[17:29:17.072]                             if (!grepl(pattern, name)) 
[17:29:17.072]                               next
[17:29:17.072]                             invokeRestart(restart)
[17:29:17.072]                             muffled <- TRUE
[17:29:17.072]                             break
[17:29:17.072]                           }
[17:29:17.072]                         }
[17:29:17.072]                       }
[17:29:17.072]                       invisible(muffled)
[17:29:17.072]                     }
[17:29:17.072]                     muffleCondition(cond, pattern = "^muffle")
[17:29:17.072]                   }
[17:29:17.072]                 }
[17:29:17.072]                 else {
[17:29:17.072]                   if (TRUE) {
[17:29:17.072]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:17.072]                     {
[17:29:17.072]                       inherits <- base::inherits
[17:29:17.072]                       invokeRestart <- base::invokeRestart
[17:29:17.072]                       is.null <- base::is.null
[17:29:17.072]                       muffled <- FALSE
[17:29:17.072]                       if (inherits(cond, "message")) {
[17:29:17.072]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:17.072]                         if (muffled) 
[17:29:17.072]                           invokeRestart("muffleMessage")
[17:29:17.072]                       }
[17:29:17.072]                       else if (inherits(cond, "warning")) {
[17:29:17.072]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:17.072]                         if (muffled) 
[17:29:17.072]                           invokeRestart("muffleWarning")
[17:29:17.072]                       }
[17:29:17.072]                       else if (inherits(cond, "condition")) {
[17:29:17.072]                         if (!is.null(pattern)) {
[17:29:17.072]                           computeRestarts <- base::computeRestarts
[17:29:17.072]                           grepl <- base::grepl
[17:29:17.072]                           restarts <- computeRestarts(cond)
[17:29:17.072]                           for (restart in restarts) {
[17:29:17.072]                             name <- restart$name
[17:29:17.072]                             if (is.null(name)) 
[17:29:17.072]                               next
[17:29:17.072]                             if (!grepl(pattern, name)) 
[17:29:17.072]                               next
[17:29:17.072]                             invokeRestart(restart)
[17:29:17.072]                             muffled <- TRUE
[17:29:17.072]                             break
[17:29:17.072]                           }
[17:29:17.072]                         }
[17:29:17.072]                       }
[17:29:17.072]                       invisible(muffled)
[17:29:17.072]                     }
[17:29:17.072]                     muffleCondition(cond, pattern = "^muffle")
[17:29:17.072]                   }
[17:29:17.072]                 }
[17:29:17.072]             }
[17:29:17.072]         }))
[17:29:17.072]     }, error = function(ex) {
[17:29:17.072]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:17.072]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:17.072]                 ...future.rng), started = ...future.startTime, 
[17:29:17.072]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:17.072]             version = "1.8"), class = "FutureResult")
[17:29:17.072]     }, finally = {
[17:29:17.072]         if (!identical(...future.workdir, getwd())) 
[17:29:17.072]             setwd(...future.workdir)
[17:29:17.072]         {
[17:29:17.072]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:17.072]                 ...future.oldOptions$nwarnings <- NULL
[17:29:17.072]             }
[17:29:17.072]             base::options(...future.oldOptions)
[17:29:17.072]             if (.Platform$OS.type == "windows") {
[17:29:17.072]                 old_names <- names(...future.oldEnvVars)
[17:29:17.072]                 envs <- base::Sys.getenv()
[17:29:17.072]                 names <- names(envs)
[17:29:17.072]                 common <- intersect(names, old_names)
[17:29:17.072]                 added <- setdiff(names, old_names)
[17:29:17.072]                 removed <- setdiff(old_names, names)
[17:29:17.072]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:17.072]                   envs[common]]
[17:29:17.072]                 NAMES <- toupper(changed)
[17:29:17.072]                 args <- list()
[17:29:17.072]                 for (kk in seq_along(NAMES)) {
[17:29:17.072]                   name <- changed[[kk]]
[17:29:17.072]                   NAME <- NAMES[[kk]]
[17:29:17.072]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:17.072]                     next
[17:29:17.072]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:17.072]                 }
[17:29:17.072]                 NAMES <- toupper(added)
[17:29:17.072]                 for (kk in seq_along(NAMES)) {
[17:29:17.072]                   name <- added[[kk]]
[17:29:17.072]                   NAME <- NAMES[[kk]]
[17:29:17.072]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:17.072]                     next
[17:29:17.072]                   args[[name]] <- ""
[17:29:17.072]                 }
[17:29:17.072]                 NAMES <- toupper(removed)
[17:29:17.072]                 for (kk in seq_along(NAMES)) {
[17:29:17.072]                   name <- removed[[kk]]
[17:29:17.072]                   NAME <- NAMES[[kk]]
[17:29:17.072]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:17.072]                     next
[17:29:17.072]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:17.072]                 }
[17:29:17.072]                 if (length(args) > 0) 
[17:29:17.072]                   base::do.call(base::Sys.setenv, args = args)
[17:29:17.072]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:17.072]             }
[17:29:17.072]             else {
[17:29:17.072]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:17.072]             }
[17:29:17.072]             {
[17:29:17.072]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:17.072]                   0L) {
[17:29:17.072]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:17.072]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:17.072]                   base::options(opts)
[17:29:17.072]                 }
[17:29:17.072]                 {
[17:29:17.072]                   {
[17:29:17.072]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:17.072]                     NULL
[17:29:17.072]                   }
[17:29:17.072]                   options(future.plan = NULL)
[17:29:17.072]                   if (is.na(NA_character_)) 
[17:29:17.072]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:17.072]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:17.072]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:17.072]                     .init = FALSE)
[17:29:17.072]                 }
[17:29:17.072]             }
[17:29:17.072]         }
[17:29:17.072]     })
[17:29:17.072]     if (TRUE) {
[17:29:17.072]         base::sink(type = "output", split = FALSE)
[17:29:17.072]         if (TRUE) {
[17:29:17.072]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:17.072]         }
[17:29:17.072]         else {
[17:29:17.072]             ...future.result["stdout"] <- base::list(NULL)
[17:29:17.072]         }
[17:29:17.072]         base::close(...future.stdout)
[17:29:17.072]         ...future.stdout <- NULL
[17:29:17.072]     }
[17:29:17.072]     ...future.result$conditions <- ...future.conditions
[17:29:17.072]     ...future.result$finished <- base::Sys.time()
[17:29:17.072]     ...future.result
[17:29:17.072] }
[17:29:17.078] MultisessionFuture started
[17:29:17.079] - Launch lazy future ... done
[17:29:17.079] run() for 'MultisessionFuture' ... done
[17:29:17.095] receiveMessageFromWorker() for ClusterFuture ...
[17:29:17.096] - Validating connection of MultisessionFuture
[17:29:17.096] - received message: FutureResult
[17:29:17.097] - Received FutureResult
[17:29:17.097] - Erased future from FutureRegistry
[17:29:17.097] result() for ClusterFuture ...
[17:29:17.097] - result already collected: FutureResult
[17:29:17.097] result() for ClusterFuture ... done
[17:29:17.098] signalConditions() ...
[17:29:17.098]  - include = 'immediateCondition'
[17:29:17.098]  - exclude = 
[17:29:17.098]  - resignal = FALSE
[17:29:17.098]  - Number of conditions: 1
[17:29:17.098] signalConditions() ... done
[17:29:17.099] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:17.099] A MultisessionFuture was resolved
- result = TRUE, recursive = FALSE ... DONE
- result = TRUE, recursive = TRUE ...
[17:29:17.099] getGlobalsAndPackages() ...
[17:29:17.099] Searching for globals...
[17:29:17.101] - globals found: [3] '{', 'Sys.sleep', 'list'
[17:29:17.101] Searching for globals ... DONE
[17:29:17.101] Resolving globals: FALSE
[17:29:17.102] 
[17:29:17.102] 
[17:29:17.102] getGlobalsAndPackages() ... DONE
[17:29:17.103] run() for 'Future' ...
[17:29:17.103] - state: 'created'
[17:29:17.103] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:17.120] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:17.120] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:17.120]   - Field: 'node'
[17:29:17.120]   - Field: 'label'
[17:29:17.121]   - Field: 'local'
[17:29:17.121]   - Field: 'owner'
[17:29:17.121]   - Field: 'envir'
[17:29:17.121]   - Field: 'workers'
[17:29:17.121]   - Field: 'packages'
[17:29:17.121]   - Field: 'gc'
[17:29:17.122]   - Field: 'conditions'
[17:29:17.122]   - Field: 'persistent'
[17:29:17.122]   - Field: 'expr'
[17:29:17.122]   - Field: 'uuid'
[17:29:17.122]   - Field: 'seed'
[17:29:17.122]   - Field: 'version'
[17:29:17.123]   - Field: 'result'
[17:29:17.123]   - Field: 'asynchronous'
[17:29:17.123]   - Field: 'calls'
[17:29:17.123]   - Field: 'globals'
[17:29:17.123]   - Field: 'stdout'
[17:29:17.124]   - Field: 'earlySignal'
[17:29:17.124]   - Field: 'lazy'
[17:29:17.124]   - Field: 'state'
[17:29:17.124] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:17.124] - Launch lazy future ...
[17:29:17.125] Packages needed by the future expression (n = 0): <none>
[17:29:17.125] Packages needed by future strategies (n = 0): <none>
[17:29:17.126] {
[17:29:17.126]     {
[17:29:17.126]         {
[17:29:17.126]             ...future.startTime <- base::Sys.time()
[17:29:17.126]             {
[17:29:17.126]                 {
[17:29:17.126]                   {
[17:29:17.126]                     {
[17:29:17.126]                       base::local({
[17:29:17.126]                         has_future <- base::requireNamespace("future", 
[17:29:17.126]                           quietly = TRUE)
[17:29:17.126]                         if (has_future) {
[17:29:17.126]                           ns <- base::getNamespace("future")
[17:29:17.126]                           version <- ns[[".package"]][["version"]]
[17:29:17.126]                           if (is.null(version)) 
[17:29:17.126]                             version <- utils::packageVersion("future")
[17:29:17.126]                         }
[17:29:17.126]                         else {
[17:29:17.126]                           version <- NULL
[17:29:17.126]                         }
[17:29:17.126]                         if (!has_future || version < "1.8.0") {
[17:29:17.126]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:17.126]                             "", base::R.version$version.string), 
[17:29:17.126]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:17.126]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:17.126]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:17.126]                               "release", "version")], collapse = " "), 
[17:29:17.126]                             hostname = base::Sys.info()[["nodename"]])
[17:29:17.126]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:17.126]                             info)
[17:29:17.126]                           info <- base::paste(info, collapse = "; ")
[17:29:17.126]                           if (!has_future) {
[17:29:17.126]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:17.126]                               info)
[17:29:17.126]                           }
[17:29:17.126]                           else {
[17:29:17.126]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:17.126]                               info, version)
[17:29:17.126]                           }
[17:29:17.126]                           base::stop(msg)
[17:29:17.126]                         }
[17:29:17.126]                       })
[17:29:17.126]                     }
[17:29:17.126]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:17.126]                     base::options(mc.cores = 1L)
[17:29:17.126]                   }
[17:29:17.126]                   ...future.strategy.old <- future::plan("list")
[17:29:17.126]                   options(future.plan = NULL)
[17:29:17.126]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:17.126]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:17.126]                 }
[17:29:17.126]                 ...future.workdir <- getwd()
[17:29:17.126]             }
[17:29:17.126]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:17.126]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:17.126]         }
[17:29:17.126]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:17.126]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:17.126]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:17.126]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:17.126]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:17.126]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:17.126]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:17.126]             base::names(...future.oldOptions))
[17:29:17.126]     }
[17:29:17.126]     if (FALSE) {
[17:29:17.126]     }
[17:29:17.126]     else {
[17:29:17.126]         if (TRUE) {
[17:29:17.126]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:17.126]                 open = "w")
[17:29:17.126]         }
[17:29:17.126]         else {
[17:29:17.126]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:17.126]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:17.126]         }
[17:29:17.126]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:17.126]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:17.126]             base::sink(type = "output", split = FALSE)
[17:29:17.126]             base::close(...future.stdout)
[17:29:17.126]         }, add = TRUE)
[17:29:17.126]     }
[17:29:17.126]     ...future.frame <- base::sys.nframe()
[17:29:17.126]     ...future.conditions <- base::list()
[17:29:17.126]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:17.126]     if (FALSE) {
[17:29:17.126]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:17.126]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:17.126]     }
[17:29:17.126]     ...future.result <- base::tryCatch({
[17:29:17.126]         base::withCallingHandlers({
[17:29:17.126]             ...future.value <- base::withVisible(base::local({
[17:29:17.126]                 ...future.makeSendCondition <- base::local({
[17:29:17.126]                   sendCondition <- NULL
[17:29:17.126]                   function(frame = 1L) {
[17:29:17.126]                     if (is.function(sendCondition)) 
[17:29:17.126]                       return(sendCondition)
[17:29:17.126]                     ns <- getNamespace("parallel")
[17:29:17.126]                     if (exists("sendData", mode = "function", 
[17:29:17.126]                       envir = ns)) {
[17:29:17.126]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:17.126]                         envir = ns)
[17:29:17.126]                       envir <- sys.frame(frame)
[17:29:17.126]                       master <- NULL
[17:29:17.126]                       while (!identical(envir, .GlobalEnv) && 
[17:29:17.126]                         !identical(envir, emptyenv())) {
[17:29:17.126]                         if (exists("master", mode = "list", envir = envir, 
[17:29:17.126]                           inherits = FALSE)) {
[17:29:17.126]                           master <- get("master", mode = "list", 
[17:29:17.126]                             envir = envir, inherits = FALSE)
[17:29:17.126]                           if (inherits(master, c("SOCKnode", 
[17:29:17.126]                             "SOCK0node"))) {
[17:29:17.126]                             sendCondition <<- function(cond) {
[17:29:17.126]                               data <- list(type = "VALUE", value = cond, 
[17:29:17.126]                                 success = TRUE)
[17:29:17.126]                               parallel_sendData(master, data)
[17:29:17.126]                             }
[17:29:17.126]                             return(sendCondition)
[17:29:17.126]                           }
[17:29:17.126]                         }
[17:29:17.126]                         frame <- frame + 1L
[17:29:17.126]                         envir <- sys.frame(frame)
[17:29:17.126]                       }
[17:29:17.126]                     }
[17:29:17.126]                     sendCondition <<- function(cond) NULL
[17:29:17.126]                   }
[17:29:17.126]                 })
[17:29:17.126]                 withCallingHandlers({
[17:29:17.126]                   {
[17:29:17.126]                     Sys.sleep(0.5)
[17:29:17.126]                     list(a = 1, b = 42L)
[17:29:17.126]                   }
[17:29:17.126]                 }, immediateCondition = function(cond) {
[17:29:17.126]                   sendCondition <- ...future.makeSendCondition()
[17:29:17.126]                   sendCondition(cond)
[17:29:17.126]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:17.126]                   {
[17:29:17.126]                     inherits <- base::inherits
[17:29:17.126]                     invokeRestart <- base::invokeRestart
[17:29:17.126]                     is.null <- base::is.null
[17:29:17.126]                     muffled <- FALSE
[17:29:17.126]                     if (inherits(cond, "message")) {
[17:29:17.126]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:17.126]                       if (muffled) 
[17:29:17.126]                         invokeRestart("muffleMessage")
[17:29:17.126]                     }
[17:29:17.126]                     else if (inherits(cond, "warning")) {
[17:29:17.126]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:17.126]                       if (muffled) 
[17:29:17.126]                         invokeRestart("muffleWarning")
[17:29:17.126]                     }
[17:29:17.126]                     else if (inherits(cond, "condition")) {
[17:29:17.126]                       if (!is.null(pattern)) {
[17:29:17.126]                         computeRestarts <- base::computeRestarts
[17:29:17.126]                         grepl <- base::grepl
[17:29:17.126]                         restarts <- computeRestarts(cond)
[17:29:17.126]                         for (restart in restarts) {
[17:29:17.126]                           name <- restart$name
[17:29:17.126]                           if (is.null(name)) 
[17:29:17.126]                             next
[17:29:17.126]                           if (!grepl(pattern, name)) 
[17:29:17.126]                             next
[17:29:17.126]                           invokeRestart(restart)
[17:29:17.126]                           muffled <- TRUE
[17:29:17.126]                           break
[17:29:17.126]                         }
[17:29:17.126]                       }
[17:29:17.126]                     }
[17:29:17.126]                     invisible(muffled)
[17:29:17.126]                   }
[17:29:17.126]                   muffleCondition(cond)
[17:29:17.126]                 })
[17:29:17.126]             }))
[17:29:17.126]             future::FutureResult(value = ...future.value$value, 
[17:29:17.126]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:17.126]                   ...future.rng), globalenv = if (FALSE) 
[17:29:17.126]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:17.126]                     ...future.globalenv.names))
[17:29:17.126]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:17.126]         }, condition = base::local({
[17:29:17.126]             c <- base::c
[17:29:17.126]             inherits <- base::inherits
[17:29:17.126]             invokeRestart <- base::invokeRestart
[17:29:17.126]             length <- base::length
[17:29:17.126]             list <- base::list
[17:29:17.126]             seq.int <- base::seq.int
[17:29:17.126]             signalCondition <- base::signalCondition
[17:29:17.126]             sys.calls <- base::sys.calls
[17:29:17.126]             `[[` <- base::`[[`
[17:29:17.126]             `+` <- base::`+`
[17:29:17.126]             `<<-` <- base::`<<-`
[17:29:17.126]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:17.126]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:17.126]                   3L)]
[17:29:17.126]             }
[17:29:17.126]             function(cond) {
[17:29:17.126]                 is_error <- inherits(cond, "error")
[17:29:17.126]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:17.126]                   NULL)
[17:29:17.126]                 if (is_error) {
[17:29:17.126]                   sessionInformation <- function() {
[17:29:17.126]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:17.126]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:17.126]                       search = base::search(), system = base::Sys.info())
[17:29:17.126]                   }
[17:29:17.126]                   ...future.conditions[[length(...future.conditions) + 
[17:29:17.126]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:17.126]                     cond$call), session = sessionInformation(), 
[17:29:17.126]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:17.126]                   signalCondition(cond)
[17:29:17.126]                 }
[17:29:17.126]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:17.126]                 "immediateCondition"))) {
[17:29:17.126]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:17.126]                   ...future.conditions[[length(...future.conditions) + 
[17:29:17.126]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:17.126]                   if (TRUE && !signal) {
[17:29:17.126]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:17.126]                     {
[17:29:17.126]                       inherits <- base::inherits
[17:29:17.126]                       invokeRestart <- base::invokeRestart
[17:29:17.126]                       is.null <- base::is.null
[17:29:17.126]                       muffled <- FALSE
[17:29:17.126]                       if (inherits(cond, "message")) {
[17:29:17.126]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:17.126]                         if (muffled) 
[17:29:17.126]                           invokeRestart("muffleMessage")
[17:29:17.126]                       }
[17:29:17.126]                       else if (inherits(cond, "warning")) {
[17:29:17.126]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:17.126]                         if (muffled) 
[17:29:17.126]                           invokeRestart("muffleWarning")
[17:29:17.126]                       }
[17:29:17.126]                       else if (inherits(cond, "condition")) {
[17:29:17.126]                         if (!is.null(pattern)) {
[17:29:17.126]                           computeRestarts <- base::computeRestarts
[17:29:17.126]                           grepl <- base::grepl
[17:29:17.126]                           restarts <- computeRestarts(cond)
[17:29:17.126]                           for (restart in restarts) {
[17:29:17.126]                             name <- restart$name
[17:29:17.126]                             if (is.null(name)) 
[17:29:17.126]                               next
[17:29:17.126]                             if (!grepl(pattern, name)) 
[17:29:17.126]                               next
[17:29:17.126]                             invokeRestart(restart)
[17:29:17.126]                             muffled <- TRUE
[17:29:17.126]                             break
[17:29:17.126]                           }
[17:29:17.126]                         }
[17:29:17.126]                       }
[17:29:17.126]                       invisible(muffled)
[17:29:17.126]                     }
[17:29:17.126]                     muffleCondition(cond, pattern = "^muffle")
[17:29:17.126]                   }
[17:29:17.126]                 }
[17:29:17.126]                 else {
[17:29:17.126]                   if (TRUE) {
[17:29:17.126]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:17.126]                     {
[17:29:17.126]                       inherits <- base::inherits
[17:29:17.126]                       invokeRestart <- base::invokeRestart
[17:29:17.126]                       is.null <- base::is.null
[17:29:17.126]                       muffled <- FALSE
[17:29:17.126]                       if (inherits(cond, "message")) {
[17:29:17.126]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:17.126]                         if (muffled) 
[17:29:17.126]                           invokeRestart("muffleMessage")
[17:29:17.126]                       }
[17:29:17.126]                       else if (inherits(cond, "warning")) {
[17:29:17.126]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:17.126]                         if (muffled) 
[17:29:17.126]                           invokeRestart("muffleWarning")
[17:29:17.126]                       }
[17:29:17.126]                       else if (inherits(cond, "condition")) {
[17:29:17.126]                         if (!is.null(pattern)) {
[17:29:17.126]                           computeRestarts <- base::computeRestarts
[17:29:17.126]                           grepl <- base::grepl
[17:29:17.126]                           restarts <- computeRestarts(cond)
[17:29:17.126]                           for (restart in restarts) {
[17:29:17.126]                             name <- restart$name
[17:29:17.126]                             if (is.null(name)) 
[17:29:17.126]                               next
[17:29:17.126]                             if (!grepl(pattern, name)) 
[17:29:17.126]                               next
[17:29:17.126]                             invokeRestart(restart)
[17:29:17.126]                             muffled <- TRUE
[17:29:17.126]                             break
[17:29:17.126]                           }
[17:29:17.126]                         }
[17:29:17.126]                       }
[17:29:17.126]                       invisible(muffled)
[17:29:17.126]                     }
[17:29:17.126]                     muffleCondition(cond, pattern = "^muffle")
[17:29:17.126]                   }
[17:29:17.126]                 }
[17:29:17.126]             }
[17:29:17.126]         }))
[17:29:17.126]     }, error = function(ex) {
[17:29:17.126]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:17.126]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:17.126]                 ...future.rng), started = ...future.startTime, 
[17:29:17.126]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:17.126]             version = "1.8"), class = "FutureResult")
[17:29:17.126]     }, finally = {
[17:29:17.126]         if (!identical(...future.workdir, getwd())) 
[17:29:17.126]             setwd(...future.workdir)
[17:29:17.126]         {
[17:29:17.126]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:17.126]                 ...future.oldOptions$nwarnings <- NULL
[17:29:17.126]             }
[17:29:17.126]             base::options(...future.oldOptions)
[17:29:17.126]             if (.Platform$OS.type == "windows") {
[17:29:17.126]                 old_names <- names(...future.oldEnvVars)
[17:29:17.126]                 envs <- base::Sys.getenv()
[17:29:17.126]                 names <- names(envs)
[17:29:17.126]                 common <- intersect(names, old_names)
[17:29:17.126]                 added <- setdiff(names, old_names)
[17:29:17.126]                 removed <- setdiff(old_names, names)
[17:29:17.126]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:17.126]                   envs[common]]
[17:29:17.126]                 NAMES <- toupper(changed)
[17:29:17.126]                 args <- list()
[17:29:17.126]                 for (kk in seq_along(NAMES)) {
[17:29:17.126]                   name <- changed[[kk]]
[17:29:17.126]                   NAME <- NAMES[[kk]]
[17:29:17.126]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:17.126]                     next
[17:29:17.126]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:17.126]                 }
[17:29:17.126]                 NAMES <- toupper(added)
[17:29:17.126]                 for (kk in seq_along(NAMES)) {
[17:29:17.126]                   name <- added[[kk]]
[17:29:17.126]                   NAME <- NAMES[[kk]]
[17:29:17.126]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:17.126]                     next
[17:29:17.126]                   args[[name]] <- ""
[17:29:17.126]                 }
[17:29:17.126]                 NAMES <- toupper(removed)
[17:29:17.126]                 for (kk in seq_along(NAMES)) {
[17:29:17.126]                   name <- removed[[kk]]
[17:29:17.126]                   NAME <- NAMES[[kk]]
[17:29:17.126]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:17.126]                     next
[17:29:17.126]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:17.126]                 }
[17:29:17.126]                 if (length(args) > 0) 
[17:29:17.126]                   base::do.call(base::Sys.setenv, args = args)
[17:29:17.126]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:17.126]             }
[17:29:17.126]             else {
[17:29:17.126]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:17.126]             }
[17:29:17.126]             {
[17:29:17.126]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:17.126]                   0L) {
[17:29:17.126]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:17.126]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:17.126]                   base::options(opts)
[17:29:17.126]                 }
[17:29:17.126]                 {
[17:29:17.126]                   {
[17:29:17.126]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:17.126]                     NULL
[17:29:17.126]                   }
[17:29:17.126]                   options(future.plan = NULL)
[17:29:17.126]                   if (is.na(NA_character_)) 
[17:29:17.126]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:17.126]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:17.126]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:17.126]                     .init = FALSE)
[17:29:17.126]                 }
[17:29:17.126]             }
[17:29:17.126]         }
[17:29:17.126]     })
[17:29:17.126]     if (TRUE) {
[17:29:17.126]         base::sink(type = "output", split = FALSE)
[17:29:17.126]         if (TRUE) {
[17:29:17.126]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:17.126]         }
[17:29:17.126]         else {
[17:29:17.126]             ...future.result["stdout"] <- base::list(NULL)
[17:29:17.126]         }
[17:29:17.126]         base::close(...future.stdout)
[17:29:17.126]         ...future.stdout <- NULL
[17:29:17.126]     }
[17:29:17.126]     ...future.result$conditions <- ...future.conditions
[17:29:17.126]     ...future.result$finished <- base::Sys.time()
[17:29:17.126]     ...future.result
[17:29:17.126] }
[17:29:17.132] MultisessionFuture started
[17:29:17.132] - Launch lazy future ... done
[17:29:17.132] run() for 'MultisessionFuture' ... done
[17:29:17.667] receiveMessageFromWorker() for ClusterFuture ...
[17:29:17.668] - Validating connection of MultisessionFuture
[17:29:17.668] - received message: FutureResult
[17:29:17.668] - Received FutureResult
[17:29:17.669] - Erased future from FutureRegistry
[17:29:17.669] result() for ClusterFuture ...
[17:29:17.669] - result already collected: FutureResult
[17:29:17.669] result() for ClusterFuture ... done
[17:29:17.669] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:17.670] resolve() on list ...
[17:29:17.670]  recursive: 98
[17:29:17.670]  length: 2
[17:29:17.670]  elements: 'a', 'b'
[17:29:17.670]  length: 1 (resolved future 1)
[17:29:17.671]  length: 0 (resolved future 2)
[17:29:17.671] resolve() on list ... DONE
[17:29:17.671] A MultisessionFuture was resolved (and resolved itself)
[17:29:17.671] getGlobalsAndPackages() ...
[17:29:17.671] Searching for globals...
[17:29:17.673] - globals found: [3] '{', 'Sys.sleep', 'list'
[17:29:17.673] Searching for globals ... DONE
[17:29:17.674] Resolving globals: FALSE
[17:29:17.674] 
[17:29:17.674] 
[17:29:17.674] getGlobalsAndPackages() ... DONE
[17:29:17.675] run() for 'Future' ...
[17:29:17.676] - state: 'created'
[17:29:17.676] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:17.692] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:17.693] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:17.693]   - Field: 'node'
[17:29:17.693]   - Field: 'label'
[17:29:17.693]   - Field: 'local'
[17:29:17.694]   - Field: 'owner'
[17:29:17.694]   - Field: 'envir'
[17:29:17.694]   - Field: 'workers'
[17:29:17.694]   - Field: 'packages'
[17:29:17.694]   - Field: 'gc'
[17:29:17.695]   - Field: 'conditions'
[17:29:17.695]   - Field: 'persistent'
[17:29:17.695]   - Field: 'expr'
[17:29:17.695]   - Field: 'uuid'
[17:29:17.695]   - Field: 'seed'
[17:29:17.695]   - Field: 'version'
[17:29:17.696]   - Field: 'result'
[17:29:17.696]   - Field: 'asynchronous'
[17:29:17.696]   - Field: 'calls'
[17:29:17.696]   - Field: 'globals'
[17:29:17.696]   - Field: 'stdout'
[17:29:17.697]   - Field: 'earlySignal'
[17:29:17.697]   - Field: 'lazy'
[17:29:17.697]   - Field: 'state'
[17:29:17.697] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:17.697] - Launch lazy future ...
[17:29:17.698] Packages needed by the future expression (n = 0): <none>
[17:29:17.698] Packages needed by future strategies (n = 0): <none>
[17:29:17.699] {
[17:29:17.699]     {
[17:29:17.699]         {
[17:29:17.699]             ...future.startTime <- base::Sys.time()
[17:29:17.699]             {
[17:29:17.699]                 {
[17:29:17.699]                   {
[17:29:17.699]                     {
[17:29:17.699]                       base::local({
[17:29:17.699]                         has_future <- base::requireNamespace("future", 
[17:29:17.699]                           quietly = TRUE)
[17:29:17.699]                         if (has_future) {
[17:29:17.699]                           ns <- base::getNamespace("future")
[17:29:17.699]                           version <- ns[[".package"]][["version"]]
[17:29:17.699]                           if (is.null(version)) 
[17:29:17.699]                             version <- utils::packageVersion("future")
[17:29:17.699]                         }
[17:29:17.699]                         else {
[17:29:17.699]                           version <- NULL
[17:29:17.699]                         }
[17:29:17.699]                         if (!has_future || version < "1.8.0") {
[17:29:17.699]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:17.699]                             "", base::R.version$version.string), 
[17:29:17.699]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:17.699]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:17.699]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:17.699]                               "release", "version")], collapse = " "), 
[17:29:17.699]                             hostname = base::Sys.info()[["nodename"]])
[17:29:17.699]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:17.699]                             info)
[17:29:17.699]                           info <- base::paste(info, collapse = "; ")
[17:29:17.699]                           if (!has_future) {
[17:29:17.699]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:17.699]                               info)
[17:29:17.699]                           }
[17:29:17.699]                           else {
[17:29:17.699]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:17.699]                               info, version)
[17:29:17.699]                           }
[17:29:17.699]                           base::stop(msg)
[17:29:17.699]                         }
[17:29:17.699]                       })
[17:29:17.699]                     }
[17:29:17.699]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:17.699]                     base::options(mc.cores = 1L)
[17:29:17.699]                   }
[17:29:17.699]                   ...future.strategy.old <- future::plan("list")
[17:29:17.699]                   options(future.plan = NULL)
[17:29:17.699]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:17.699]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:17.699]                 }
[17:29:17.699]                 ...future.workdir <- getwd()
[17:29:17.699]             }
[17:29:17.699]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:17.699]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:17.699]         }
[17:29:17.699]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:17.699]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:17.699]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:17.699]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:17.699]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:17.699]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:17.699]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:17.699]             base::names(...future.oldOptions))
[17:29:17.699]     }
[17:29:17.699]     if (FALSE) {
[17:29:17.699]     }
[17:29:17.699]     else {
[17:29:17.699]         if (TRUE) {
[17:29:17.699]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:17.699]                 open = "w")
[17:29:17.699]         }
[17:29:17.699]         else {
[17:29:17.699]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:17.699]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:17.699]         }
[17:29:17.699]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:17.699]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:17.699]             base::sink(type = "output", split = FALSE)
[17:29:17.699]             base::close(...future.stdout)
[17:29:17.699]         }, add = TRUE)
[17:29:17.699]     }
[17:29:17.699]     ...future.frame <- base::sys.nframe()
[17:29:17.699]     ...future.conditions <- base::list()
[17:29:17.699]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:17.699]     if (FALSE) {
[17:29:17.699]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:17.699]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:17.699]     }
[17:29:17.699]     ...future.result <- base::tryCatch({
[17:29:17.699]         base::withCallingHandlers({
[17:29:17.699]             ...future.value <- base::withVisible(base::local({
[17:29:17.699]                 ...future.makeSendCondition <- base::local({
[17:29:17.699]                   sendCondition <- NULL
[17:29:17.699]                   function(frame = 1L) {
[17:29:17.699]                     if (is.function(sendCondition)) 
[17:29:17.699]                       return(sendCondition)
[17:29:17.699]                     ns <- getNamespace("parallel")
[17:29:17.699]                     if (exists("sendData", mode = "function", 
[17:29:17.699]                       envir = ns)) {
[17:29:17.699]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:17.699]                         envir = ns)
[17:29:17.699]                       envir <- sys.frame(frame)
[17:29:17.699]                       master <- NULL
[17:29:17.699]                       while (!identical(envir, .GlobalEnv) && 
[17:29:17.699]                         !identical(envir, emptyenv())) {
[17:29:17.699]                         if (exists("master", mode = "list", envir = envir, 
[17:29:17.699]                           inherits = FALSE)) {
[17:29:17.699]                           master <- get("master", mode = "list", 
[17:29:17.699]                             envir = envir, inherits = FALSE)
[17:29:17.699]                           if (inherits(master, c("SOCKnode", 
[17:29:17.699]                             "SOCK0node"))) {
[17:29:17.699]                             sendCondition <<- function(cond) {
[17:29:17.699]                               data <- list(type = "VALUE", value = cond, 
[17:29:17.699]                                 success = TRUE)
[17:29:17.699]                               parallel_sendData(master, data)
[17:29:17.699]                             }
[17:29:17.699]                             return(sendCondition)
[17:29:17.699]                           }
[17:29:17.699]                         }
[17:29:17.699]                         frame <- frame + 1L
[17:29:17.699]                         envir <- sys.frame(frame)
[17:29:17.699]                       }
[17:29:17.699]                     }
[17:29:17.699]                     sendCondition <<- function(cond) NULL
[17:29:17.699]                   }
[17:29:17.699]                 })
[17:29:17.699]                 withCallingHandlers({
[17:29:17.699]                   {
[17:29:17.699]                     Sys.sleep(0.5)
[17:29:17.699]                     list(a = 1, b = 42L)
[17:29:17.699]                   }
[17:29:17.699]                 }, immediateCondition = function(cond) {
[17:29:17.699]                   sendCondition <- ...future.makeSendCondition()
[17:29:17.699]                   sendCondition(cond)
[17:29:17.699]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:17.699]                   {
[17:29:17.699]                     inherits <- base::inherits
[17:29:17.699]                     invokeRestart <- base::invokeRestart
[17:29:17.699]                     is.null <- base::is.null
[17:29:17.699]                     muffled <- FALSE
[17:29:17.699]                     if (inherits(cond, "message")) {
[17:29:17.699]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:17.699]                       if (muffled) 
[17:29:17.699]                         invokeRestart("muffleMessage")
[17:29:17.699]                     }
[17:29:17.699]                     else if (inherits(cond, "warning")) {
[17:29:17.699]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:17.699]                       if (muffled) 
[17:29:17.699]                         invokeRestart("muffleWarning")
[17:29:17.699]                     }
[17:29:17.699]                     else if (inherits(cond, "condition")) {
[17:29:17.699]                       if (!is.null(pattern)) {
[17:29:17.699]                         computeRestarts <- base::computeRestarts
[17:29:17.699]                         grepl <- base::grepl
[17:29:17.699]                         restarts <- computeRestarts(cond)
[17:29:17.699]                         for (restart in restarts) {
[17:29:17.699]                           name <- restart$name
[17:29:17.699]                           if (is.null(name)) 
[17:29:17.699]                             next
[17:29:17.699]                           if (!grepl(pattern, name)) 
[17:29:17.699]                             next
[17:29:17.699]                           invokeRestart(restart)
[17:29:17.699]                           muffled <- TRUE
[17:29:17.699]                           break
[17:29:17.699]                         }
[17:29:17.699]                       }
[17:29:17.699]                     }
[17:29:17.699]                     invisible(muffled)
[17:29:17.699]                   }
[17:29:17.699]                   muffleCondition(cond)
[17:29:17.699]                 })
[17:29:17.699]             }))
[17:29:17.699]             future::FutureResult(value = ...future.value$value, 
[17:29:17.699]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:17.699]                   ...future.rng), globalenv = if (FALSE) 
[17:29:17.699]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:17.699]                     ...future.globalenv.names))
[17:29:17.699]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:17.699]         }, condition = base::local({
[17:29:17.699]             c <- base::c
[17:29:17.699]             inherits <- base::inherits
[17:29:17.699]             invokeRestart <- base::invokeRestart
[17:29:17.699]             length <- base::length
[17:29:17.699]             list <- base::list
[17:29:17.699]             seq.int <- base::seq.int
[17:29:17.699]             signalCondition <- base::signalCondition
[17:29:17.699]             sys.calls <- base::sys.calls
[17:29:17.699]             `[[` <- base::`[[`
[17:29:17.699]             `+` <- base::`+`
[17:29:17.699]             `<<-` <- base::`<<-`
[17:29:17.699]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:17.699]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:17.699]                   3L)]
[17:29:17.699]             }
[17:29:17.699]             function(cond) {
[17:29:17.699]                 is_error <- inherits(cond, "error")
[17:29:17.699]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:17.699]                   NULL)
[17:29:17.699]                 if (is_error) {
[17:29:17.699]                   sessionInformation <- function() {
[17:29:17.699]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:17.699]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:17.699]                       search = base::search(), system = base::Sys.info())
[17:29:17.699]                   }
[17:29:17.699]                   ...future.conditions[[length(...future.conditions) + 
[17:29:17.699]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:17.699]                     cond$call), session = sessionInformation(), 
[17:29:17.699]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:17.699]                   signalCondition(cond)
[17:29:17.699]                 }
[17:29:17.699]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:17.699]                 "immediateCondition"))) {
[17:29:17.699]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:17.699]                   ...future.conditions[[length(...future.conditions) + 
[17:29:17.699]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:17.699]                   if (TRUE && !signal) {
[17:29:17.699]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:17.699]                     {
[17:29:17.699]                       inherits <- base::inherits
[17:29:17.699]                       invokeRestart <- base::invokeRestart
[17:29:17.699]                       is.null <- base::is.null
[17:29:17.699]                       muffled <- FALSE
[17:29:17.699]                       if (inherits(cond, "message")) {
[17:29:17.699]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:17.699]                         if (muffled) 
[17:29:17.699]                           invokeRestart("muffleMessage")
[17:29:17.699]                       }
[17:29:17.699]                       else if (inherits(cond, "warning")) {
[17:29:17.699]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:17.699]                         if (muffled) 
[17:29:17.699]                           invokeRestart("muffleWarning")
[17:29:17.699]                       }
[17:29:17.699]                       else if (inherits(cond, "condition")) {
[17:29:17.699]                         if (!is.null(pattern)) {
[17:29:17.699]                           computeRestarts <- base::computeRestarts
[17:29:17.699]                           grepl <- base::grepl
[17:29:17.699]                           restarts <- computeRestarts(cond)
[17:29:17.699]                           for (restart in restarts) {
[17:29:17.699]                             name <- restart$name
[17:29:17.699]                             if (is.null(name)) 
[17:29:17.699]                               next
[17:29:17.699]                             if (!grepl(pattern, name)) 
[17:29:17.699]                               next
[17:29:17.699]                             invokeRestart(restart)
[17:29:17.699]                             muffled <- TRUE
[17:29:17.699]                             break
[17:29:17.699]                           }
[17:29:17.699]                         }
[17:29:17.699]                       }
[17:29:17.699]                       invisible(muffled)
[17:29:17.699]                     }
[17:29:17.699]                     muffleCondition(cond, pattern = "^muffle")
[17:29:17.699]                   }
[17:29:17.699]                 }
[17:29:17.699]                 else {
[17:29:17.699]                   if (TRUE) {
[17:29:17.699]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:17.699]                     {
[17:29:17.699]                       inherits <- base::inherits
[17:29:17.699]                       invokeRestart <- base::invokeRestart
[17:29:17.699]                       is.null <- base::is.null
[17:29:17.699]                       muffled <- FALSE
[17:29:17.699]                       if (inherits(cond, "message")) {
[17:29:17.699]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:17.699]                         if (muffled) 
[17:29:17.699]                           invokeRestart("muffleMessage")
[17:29:17.699]                       }
[17:29:17.699]                       else if (inherits(cond, "warning")) {
[17:29:17.699]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:17.699]                         if (muffled) 
[17:29:17.699]                           invokeRestart("muffleWarning")
[17:29:17.699]                       }
[17:29:17.699]                       else if (inherits(cond, "condition")) {
[17:29:17.699]                         if (!is.null(pattern)) {
[17:29:17.699]                           computeRestarts <- base::computeRestarts
[17:29:17.699]                           grepl <- base::grepl
[17:29:17.699]                           restarts <- computeRestarts(cond)
[17:29:17.699]                           for (restart in restarts) {
[17:29:17.699]                             name <- restart$name
[17:29:17.699]                             if (is.null(name)) 
[17:29:17.699]                               next
[17:29:17.699]                             if (!grepl(pattern, name)) 
[17:29:17.699]                               next
[17:29:17.699]                             invokeRestart(restart)
[17:29:17.699]                             muffled <- TRUE
[17:29:17.699]                             break
[17:29:17.699]                           }
[17:29:17.699]                         }
[17:29:17.699]                       }
[17:29:17.699]                       invisible(muffled)
[17:29:17.699]                     }
[17:29:17.699]                     muffleCondition(cond, pattern = "^muffle")
[17:29:17.699]                   }
[17:29:17.699]                 }
[17:29:17.699]             }
[17:29:17.699]         }))
[17:29:17.699]     }, error = function(ex) {
[17:29:17.699]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:17.699]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:17.699]                 ...future.rng), started = ...future.startTime, 
[17:29:17.699]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:17.699]             version = "1.8"), class = "FutureResult")
[17:29:17.699]     }, finally = {
[17:29:17.699]         if (!identical(...future.workdir, getwd())) 
[17:29:17.699]             setwd(...future.workdir)
[17:29:17.699]         {
[17:29:17.699]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:17.699]                 ...future.oldOptions$nwarnings <- NULL
[17:29:17.699]             }
[17:29:17.699]             base::options(...future.oldOptions)
[17:29:17.699]             if (.Platform$OS.type == "windows") {
[17:29:17.699]                 old_names <- names(...future.oldEnvVars)
[17:29:17.699]                 envs <- base::Sys.getenv()
[17:29:17.699]                 names <- names(envs)
[17:29:17.699]                 common <- intersect(names, old_names)
[17:29:17.699]                 added <- setdiff(names, old_names)
[17:29:17.699]                 removed <- setdiff(old_names, names)
[17:29:17.699]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:17.699]                   envs[common]]
[17:29:17.699]                 NAMES <- toupper(changed)
[17:29:17.699]                 args <- list()
[17:29:17.699]                 for (kk in seq_along(NAMES)) {
[17:29:17.699]                   name <- changed[[kk]]
[17:29:17.699]                   NAME <- NAMES[[kk]]
[17:29:17.699]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:17.699]                     next
[17:29:17.699]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:17.699]                 }
[17:29:17.699]                 NAMES <- toupper(added)
[17:29:17.699]                 for (kk in seq_along(NAMES)) {
[17:29:17.699]                   name <- added[[kk]]
[17:29:17.699]                   NAME <- NAMES[[kk]]
[17:29:17.699]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:17.699]                     next
[17:29:17.699]                   args[[name]] <- ""
[17:29:17.699]                 }
[17:29:17.699]                 NAMES <- toupper(removed)
[17:29:17.699]                 for (kk in seq_along(NAMES)) {
[17:29:17.699]                   name <- removed[[kk]]
[17:29:17.699]                   NAME <- NAMES[[kk]]
[17:29:17.699]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:17.699]                     next
[17:29:17.699]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:17.699]                 }
[17:29:17.699]                 if (length(args) > 0) 
[17:29:17.699]                   base::do.call(base::Sys.setenv, args = args)
[17:29:17.699]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:17.699]             }
[17:29:17.699]             else {
[17:29:17.699]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:17.699]             }
[17:29:17.699]             {
[17:29:17.699]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:17.699]                   0L) {
[17:29:17.699]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:17.699]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:17.699]                   base::options(opts)
[17:29:17.699]                 }
[17:29:17.699]                 {
[17:29:17.699]                   {
[17:29:17.699]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:17.699]                     NULL
[17:29:17.699]                   }
[17:29:17.699]                   options(future.plan = NULL)
[17:29:17.699]                   if (is.na(NA_character_)) 
[17:29:17.699]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:17.699]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:17.699]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:17.699]                     .init = FALSE)
[17:29:17.699]                 }
[17:29:17.699]             }
[17:29:17.699]         }
[17:29:17.699]     })
[17:29:17.699]     if (TRUE) {
[17:29:17.699]         base::sink(type = "output", split = FALSE)
[17:29:17.699]         if (TRUE) {
[17:29:17.699]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:17.699]         }
[17:29:17.699]         else {
[17:29:17.699]             ...future.result["stdout"] <- base::list(NULL)
[17:29:17.699]         }
[17:29:17.699]         base::close(...future.stdout)
[17:29:17.699]         ...future.stdout <- NULL
[17:29:17.699]     }
[17:29:17.699]     ...future.result$conditions <- ...future.conditions
[17:29:17.699]     ...future.result$finished <- base::Sys.time()
[17:29:17.699]     ...future.result
[17:29:17.699] }
[17:29:17.705] MultisessionFuture started
[17:29:17.705] - Launch lazy future ... done
[17:29:17.706] run() for 'MultisessionFuture' ... done
[17:29:18.239] receiveMessageFromWorker() for ClusterFuture ...
[17:29:18.240] - Validating connection of MultisessionFuture
[17:29:18.240] - received message: FutureResult
[17:29:18.241] - Received FutureResult
[17:29:18.241] - Erased future from FutureRegistry
[17:29:18.241] result() for ClusterFuture ...
[17:29:18.241] - result already collected: FutureResult
[17:29:18.242] result() for ClusterFuture ... done
[17:29:18.242] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:18.242] resolve() on list ...
[17:29:18.243]  recursive: 98
[17:29:18.243]  length: 2
[17:29:18.243]  elements: 'a', 'b'
[17:29:18.244]  length: 1 (resolved future 1)
[17:29:18.244]  length: 0 (resolved future 2)
[17:29:18.244] resolve() on list ... DONE
[17:29:18.245] A MultisessionFuture was resolved (and resolved itself)
- w/ exception ...
[17:29:18.245] getGlobalsAndPackages() ...
[17:29:18.245] Searching for globals...
[17:29:18.247] - globals found: [2] 'list', 'stop'
[17:29:18.247] Searching for globals ... DONE
[17:29:18.247] Resolving globals: FALSE
[17:29:18.248] 
[17:29:18.248] 
[17:29:18.249] getGlobalsAndPackages() ... DONE
[17:29:18.249] run() for 'Future' ...
[17:29:18.250] - state: 'created'
[17:29:18.250] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:18.274] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:18.274] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:18.275]   - Field: 'node'
[17:29:18.275]   - Field: 'label'
[17:29:18.275]   - Field: 'local'
[17:29:18.276]   - Field: 'owner'
[17:29:18.276]   - Field: 'envir'
[17:29:18.276]   - Field: 'workers'
[17:29:18.276]   - Field: 'packages'
[17:29:18.277]   - Field: 'gc'
[17:29:18.277]   - Field: 'conditions'
[17:29:18.277]   - Field: 'persistent'
[17:29:18.278]   - Field: 'expr'
[17:29:18.278]   - Field: 'uuid'
[17:29:18.278]   - Field: 'seed'
[17:29:18.279]   - Field: 'version'
[17:29:18.279]   - Field: 'result'
[17:29:18.279]   - Field: 'asynchronous'
[17:29:18.280]   - Field: 'calls'
[17:29:18.280]   - Field: 'globals'
[17:29:18.280]   - Field: 'stdout'
[17:29:18.281]   - Field: 'earlySignal'
[17:29:18.281]   - Field: 'lazy'
[17:29:18.281]   - Field: 'state'
[17:29:18.282] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:18.282] - Launch lazy future ...
[17:29:18.283] Packages needed by the future expression (n = 0): <none>
[17:29:18.283] Packages needed by future strategies (n = 0): <none>
[17:29:18.284] {
[17:29:18.284]     {
[17:29:18.284]         {
[17:29:18.284]             ...future.startTime <- base::Sys.time()
[17:29:18.284]             {
[17:29:18.284]                 {
[17:29:18.284]                   {
[17:29:18.284]                     {
[17:29:18.284]                       base::local({
[17:29:18.284]                         has_future <- base::requireNamespace("future", 
[17:29:18.284]                           quietly = TRUE)
[17:29:18.284]                         if (has_future) {
[17:29:18.284]                           ns <- base::getNamespace("future")
[17:29:18.284]                           version <- ns[[".package"]][["version"]]
[17:29:18.284]                           if (is.null(version)) 
[17:29:18.284]                             version <- utils::packageVersion("future")
[17:29:18.284]                         }
[17:29:18.284]                         else {
[17:29:18.284]                           version <- NULL
[17:29:18.284]                         }
[17:29:18.284]                         if (!has_future || version < "1.8.0") {
[17:29:18.284]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:18.284]                             "", base::R.version$version.string), 
[17:29:18.284]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:18.284]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:18.284]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:18.284]                               "release", "version")], collapse = " "), 
[17:29:18.284]                             hostname = base::Sys.info()[["nodename"]])
[17:29:18.284]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:18.284]                             info)
[17:29:18.284]                           info <- base::paste(info, collapse = "; ")
[17:29:18.284]                           if (!has_future) {
[17:29:18.284]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:18.284]                               info)
[17:29:18.284]                           }
[17:29:18.284]                           else {
[17:29:18.284]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:18.284]                               info, version)
[17:29:18.284]                           }
[17:29:18.284]                           base::stop(msg)
[17:29:18.284]                         }
[17:29:18.284]                       })
[17:29:18.284]                     }
[17:29:18.284]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:18.284]                     base::options(mc.cores = 1L)
[17:29:18.284]                   }
[17:29:18.284]                   ...future.strategy.old <- future::plan("list")
[17:29:18.284]                   options(future.plan = NULL)
[17:29:18.284]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:18.284]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:18.284]                 }
[17:29:18.284]                 ...future.workdir <- getwd()
[17:29:18.284]             }
[17:29:18.284]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:18.284]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:18.284]         }
[17:29:18.284]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:18.284]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:18.284]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:18.284]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:18.284]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:18.284]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:18.284]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:18.284]             base::names(...future.oldOptions))
[17:29:18.284]     }
[17:29:18.284]     if (FALSE) {
[17:29:18.284]     }
[17:29:18.284]     else {
[17:29:18.284]         if (TRUE) {
[17:29:18.284]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:18.284]                 open = "w")
[17:29:18.284]         }
[17:29:18.284]         else {
[17:29:18.284]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:18.284]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:18.284]         }
[17:29:18.284]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:18.284]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:18.284]             base::sink(type = "output", split = FALSE)
[17:29:18.284]             base::close(...future.stdout)
[17:29:18.284]         }, add = TRUE)
[17:29:18.284]     }
[17:29:18.284]     ...future.frame <- base::sys.nframe()
[17:29:18.284]     ...future.conditions <- base::list()
[17:29:18.284]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:18.284]     if (FALSE) {
[17:29:18.284]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:18.284]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:18.284]     }
[17:29:18.284]     ...future.result <- base::tryCatch({
[17:29:18.284]         base::withCallingHandlers({
[17:29:18.284]             ...future.value <- base::withVisible(base::local({
[17:29:18.284]                 ...future.makeSendCondition <- base::local({
[17:29:18.284]                   sendCondition <- NULL
[17:29:18.284]                   function(frame = 1L) {
[17:29:18.284]                     if (is.function(sendCondition)) 
[17:29:18.284]                       return(sendCondition)
[17:29:18.284]                     ns <- getNamespace("parallel")
[17:29:18.284]                     if (exists("sendData", mode = "function", 
[17:29:18.284]                       envir = ns)) {
[17:29:18.284]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:18.284]                         envir = ns)
[17:29:18.284]                       envir <- sys.frame(frame)
[17:29:18.284]                       master <- NULL
[17:29:18.284]                       while (!identical(envir, .GlobalEnv) && 
[17:29:18.284]                         !identical(envir, emptyenv())) {
[17:29:18.284]                         if (exists("master", mode = "list", envir = envir, 
[17:29:18.284]                           inherits = FALSE)) {
[17:29:18.284]                           master <- get("master", mode = "list", 
[17:29:18.284]                             envir = envir, inherits = FALSE)
[17:29:18.284]                           if (inherits(master, c("SOCKnode", 
[17:29:18.284]                             "SOCK0node"))) {
[17:29:18.284]                             sendCondition <<- function(cond) {
[17:29:18.284]                               data <- list(type = "VALUE", value = cond, 
[17:29:18.284]                                 success = TRUE)
[17:29:18.284]                               parallel_sendData(master, data)
[17:29:18.284]                             }
[17:29:18.284]                             return(sendCondition)
[17:29:18.284]                           }
[17:29:18.284]                         }
[17:29:18.284]                         frame <- frame + 1L
[17:29:18.284]                         envir <- sys.frame(frame)
[17:29:18.284]                       }
[17:29:18.284]                     }
[17:29:18.284]                     sendCondition <<- function(cond) NULL
[17:29:18.284]                   }
[17:29:18.284]                 })
[17:29:18.284]                 withCallingHandlers({
[17:29:18.284]                   list(a = 1, b = 42L, c = stop("Nah!"))
[17:29:18.284]                 }, immediateCondition = function(cond) {
[17:29:18.284]                   sendCondition <- ...future.makeSendCondition()
[17:29:18.284]                   sendCondition(cond)
[17:29:18.284]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:18.284]                   {
[17:29:18.284]                     inherits <- base::inherits
[17:29:18.284]                     invokeRestart <- base::invokeRestart
[17:29:18.284]                     is.null <- base::is.null
[17:29:18.284]                     muffled <- FALSE
[17:29:18.284]                     if (inherits(cond, "message")) {
[17:29:18.284]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:18.284]                       if (muffled) 
[17:29:18.284]                         invokeRestart("muffleMessage")
[17:29:18.284]                     }
[17:29:18.284]                     else if (inherits(cond, "warning")) {
[17:29:18.284]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:18.284]                       if (muffled) 
[17:29:18.284]                         invokeRestart("muffleWarning")
[17:29:18.284]                     }
[17:29:18.284]                     else if (inherits(cond, "condition")) {
[17:29:18.284]                       if (!is.null(pattern)) {
[17:29:18.284]                         computeRestarts <- base::computeRestarts
[17:29:18.284]                         grepl <- base::grepl
[17:29:18.284]                         restarts <- computeRestarts(cond)
[17:29:18.284]                         for (restart in restarts) {
[17:29:18.284]                           name <- restart$name
[17:29:18.284]                           if (is.null(name)) 
[17:29:18.284]                             next
[17:29:18.284]                           if (!grepl(pattern, name)) 
[17:29:18.284]                             next
[17:29:18.284]                           invokeRestart(restart)
[17:29:18.284]                           muffled <- TRUE
[17:29:18.284]                           break
[17:29:18.284]                         }
[17:29:18.284]                       }
[17:29:18.284]                     }
[17:29:18.284]                     invisible(muffled)
[17:29:18.284]                   }
[17:29:18.284]                   muffleCondition(cond)
[17:29:18.284]                 })
[17:29:18.284]             }))
[17:29:18.284]             future::FutureResult(value = ...future.value$value, 
[17:29:18.284]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:18.284]                   ...future.rng), globalenv = if (FALSE) 
[17:29:18.284]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:18.284]                     ...future.globalenv.names))
[17:29:18.284]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:18.284]         }, condition = base::local({
[17:29:18.284]             c <- base::c
[17:29:18.284]             inherits <- base::inherits
[17:29:18.284]             invokeRestart <- base::invokeRestart
[17:29:18.284]             length <- base::length
[17:29:18.284]             list <- base::list
[17:29:18.284]             seq.int <- base::seq.int
[17:29:18.284]             signalCondition <- base::signalCondition
[17:29:18.284]             sys.calls <- base::sys.calls
[17:29:18.284]             `[[` <- base::`[[`
[17:29:18.284]             `+` <- base::`+`
[17:29:18.284]             `<<-` <- base::`<<-`
[17:29:18.284]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:18.284]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:18.284]                   3L)]
[17:29:18.284]             }
[17:29:18.284]             function(cond) {
[17:29:18.284]                 is_error <- inherits(cond, "error")
[17:29:18.284]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:18.284]                   NULL)
[17:29:18.284]                 if (is_error) {
[17:29:18.284]                   sessionInformation <- function() {
[17:29:18.284]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:18.284]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:18.284]                       search = base::search(), system = base::Sys.info())
[17:29:18.284]                   }
[17:29:18.284]                   ...future.conditions[[length(...future.conditions) + 
[17:29:18.284]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:18.284]                     cond$call), session = sessionInformation(), 
[17:29:18.284]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:18.284]                   signalCondition(cond)
[17:29:18.284]                 }
[17:29:18.284]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:18.284]                 "immediateCondition"))) {
[17:29:18.284]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:18.284]                   ...future.conditions[[length(...future.conditions) + 
[17:29:18.284]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:18.284]                   if (TRUE && !signal) {
[17:29:18.284]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:18.284]                     {
[17:29:18.284]                       inherits <- base::inherits
[17:29:18.284]                       invokeRestart <- base::invokeRestart
[17:29:18.284]                       is.null <- base::is.null
[17:29:18.284]                       muffled <- FALSE
[17:29:18.284]                       if (inherits(cond, "message")) {
[17:29:18.284]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:18.284]                         if (muffled) 
[17:29:18.284]                           invokeRestart("muffleMessage")
[17:29:18.284]                       }
[17:29:18.284]                       else if (inherits(cond, "warning")) {
[17:29:18.284]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:18.284]                         if (muffled) 
[17:29:18.284]                           invokeRestart("muffleWarning")
[17:29:18.284]                       }
[17:29:18.284]                       else if (inherits(cond, "condition")) {
[17:29:18.284]                         if (!is.null(pattern)) {
[17:29:18.284]                           computeRestarts <- base::computeRestarts
[17:29:18.284]                           grepl <- base::grepl
[17:29:18.284]                           restarts <- computeRestarts(cond)
[17:29:18.284]                           for (restart in restarts) {
[17:29:18.284]                             name <- restart$name
[17:29:18.284]                             if (is.null(name)) 
[17:29:18.284]                               next
[17:29:18.284]                             if (!grepl(pattern, name)) 
[17:29:18.284]                               next
[17:29:18.284]                             invokeRestart(restart)
[17:29:18.284]                             muffled <- TRUE
[17:29:18.284]                             break
[17:29:18.284]                           }
[17:29:18.284]                         }
[17:29:18.284]                       }
[17:29:18.284]                       invisible(muffled)
[17:29:18.284]                     }
[17:29:18.284]                     muffleCondition(cond, pattern = "^muffle")
[17:29:18.284]                   }
[17:29:18.284]                 }
[17:29:18.284]                 else {
[17:29:18.284]                   if (TRUE) {
[17:29:18.284]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:18.284]                     {
[17:29:18.284]                       inherits <- base::inherits
[17:29:18.284]                       invokeRestart <- base::invokeRestart
[17:29:18.284]                       is.null <- base::is.null
[17:29:18.284]                       muffled <- FALSE
[17:29:18.284]                       if (inherits(cond, "message")) {
[17:29:18.284]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:18.284]                         if (muffled) 
[17:29:18.284]                           invokeRestart("muffleMessage")
[17:29:18.284]                       }
[17:29:18.284]                       else if (inherits(cond, "warning")) {
[17:29:18.284]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:18.284]                         if (muffled) 
[17:29:18.284]                           invokeRestart("muffleWarning")
[17:29:18.284]                       }
[17:29:18.284]                       else if (inherits(cond, "condition")) {
[17:29:18.284]                         if (!is.null(pattern)) {
[17:29:18.284]                           computeRestarts <- base::computeRestarts
[17:29:18.284]                           grepl <- base::grepl
[17:29:18.284]                           restarts <- computeRestarts(cond)
[17:29:18.284]                           for (restart in restarts) {
[17:29:18.284]                             name <- restart$name
[17:29:18.284]                             if (is.null(name)) 
[17:29:18.284]                               next
[17:29:18.284]                             if (!grepl(pattern, name)) 
[17:29:18.284]                               next
[17:29:18.284]                             invokeRestart(restart)
[17:29:18.284]                             muffled <- TRUE
[17:29:18.284]                             break
[17:29:18.284]                           }
[17:29:18.284]                         }
[17:29:18.284]                       }
[17:29:18.284]                       invisible(muffled)
[17:29:18.284]                     }
[17:29:18.284]                     muffleCondition(cond, pattern = "^muffle")
[17:29:18.284]                   }
[17:29:18.284]                 }
[17:29:18.284]             }
[17:29:18.284]         }))
[17:29:18.284]     }, error = function(ex) {
[17:29:18.284]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:18.284]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:18.284]                 ...future.rng), started = ...future.startTime, 
[17:29:18.284]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:18.284]             version = "1.8"), class = "FutureResult")
[17:29:18.284]     }, finally = {
[17:29:18.284]         if (!identical(...future.workdir, getwd())) 
[17:29:18.284]             setwd(...future.workdir)
[17:29:18.284]         {
[17:29:18.284]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:18.284]                 ...future.oldOptions$nwarnings <- NULL
[17:29:18.284]             }
[17:29:18.284]             base::options(...future.oldOptions)
[17:29:18.284]             if (.Platform$OS.type == "windows") {
[17:29:18.284]                 old_names <- names(...future.oldEnvVars)
[17:29:18.284]                 envs <- base::Sys.getenv()
[17:29:18.284]                 names <- names(envs)
[17:29:18.284]                 common <- intersect(names, old_names)
[17:29:18.284]                 added <- setdiff(names, old_names)
[17:29:18.284]                 removed <- setdiff(old_names, names)
[17:29:18.284]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:18.284]                   envs[common]]
[17:29:18.284]                 NAMES <- toupper(changed)
[17:29:18.284]                 args <- list()
[17:29:18.284]                 for (kk in seq_along(NAMES)) {
[17:29:18.284]                   name <- changed[[kk]]
[17:29:18.284]                   NAME <- NAMES[[kk]]
[17:29:18.284]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:18.284]                     next
[17:29:18.284]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:18.284]                 }
[17:29:18.284]                 NAMES <- toupper(added)
[17:29:18.284]                 for (kk in seq_along(NAMES)) {
[17:29:18.284]                   name <- added[[kk]]
[17:29:18.284]                   NAME <- NAMES[[kk]]
[17:29:18.284]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:18.284]                     next
[17:29:18.284]                   args[[name]] <- ""
[17:29:18.284]                 }
[17:29:18.284]                 NAMES <- toupper(removed)
[17:29:18.284]                 for (kk in seq_along(NAMES)) {
[17:29:18.284]                   name <- removed[[kk]]
[17:29:18.284]                   NAME <- NAMES[[kk]]
[17:29:18.284]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:18.284]                     next
[17:29:18.284]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:18.284]                 }
[17:29:18.284]                 if (length(args) > 0) 
[17:29:18.284]                   base::do.call(base::Sys.setenv, args = args)
[17:29:18.284]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:18.284]             }
[17:29:18.284]             else {
[17:29:18.284]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:18.284]             }
[17:29:18.284]             {
[17:29:18.284]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:18.284]                   0L) {
[17:29:18.284]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:18.284]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:18.284]                   base::options(opts)
[17:29:18.284]                 }
[17:29:18.284]                 {
[17:29:18.284]                   {
[17:29:18.284]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:18.284]                     NULL
[17:29:18.284]                   }
[17:29:18.284]                   options(future.plan = NULL)
[17:29:18.284]                   if (is.na(NA_character_)) 
[17:29:18.284]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:18.284]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:18.284]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:18.284]                     .init = FALSE)
[17:29:18.284]                 }
[17:29:18.284]             }
[17:29:18.284]         }
[17:29:18.284]     })
[17:29:18.284]     if (TRUE) {
[17:29:18.284]         base::sink(type = "output", split = FALSE)
[17:29:18.284]         if (TRUE) {
[17:29:18.284]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:18.284]         }
[17:29:18.284]         else {
[17:29:18.284]             ...future.result["stdout"] <- base::list(NULL)
[17:29:18.284]         }
[17:29:18.284]         base::close(...future.stdout)
[17:29:18.284]         ...future.stdout <- NULL
[17:29:18.284]     }
[17:29:18.284]     ...future.result$conditions <- ...future.conditions
[17:29:18.284]     ...future.result$finished <- base::Sys.time()
[17:29:18.284]     ...future.result
[17:29:18.284] }
[17:29:18.295] MultisessionFuture started
[17:29:18.295] - Launch lazy future ... done
[17:29:18.296] run() for 'MultisessionFuture' ... done
[17:29:18.329] receiveMessageFromWorker() for ClusterFuture ...
[17:29:18.330] - Validating connection of MultisessionFuture
[17:29:18.331] - received message: FutureResult
[17:29:18.331] - Received FutureResult
[17:29:18.332] - Erased future from FutureRegistry
[17:29:18.332] result() for ClusterFuture ...
[17:29:18.332] - result already collected: FutureResult
[17:29:18.332] result() for ClusterFuture ... done
[17:29:18.333] signalConditions() ...
[17:29:18.333]  - include = 'immediateCondition'
[17:29:18.333]  - exclude = 
[17:29:18.333]  - resignal = FALSE
[17:29:18.334]  - Number of conditions: 1
[17:29:18.334] signalConditions() ... done
[17:29:18.334] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:18.335] A MultisessionFuture was resolved (and resolved itself)
[17:29:18.335] getGlobalsAndPackages() ...
[17:29:18.335] Searching for globals...
[17:29:18.337] - globals found: [2] 'list', 'stop'
[17:29:18.337] Searching for globals ... DONE
[17:29:18.337] Resolving globals: FALSE
[17:29:18.338] 
[17:29:18.338] 
[17:29:18.338] getGlobalsAndPackages() ... DONE
[17:29:18.339] run() for 'Future' ...
[17:29:18.339] - state: 'created'
[17:29:18.340] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:18.358] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:18.358] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:18.358]   - Field: 'node'
[17:29:18.359]   - Field: 'label'
[17:29:18.359]   - Field: 'local'
[17:29:18.359]   - Field: 'owner'
[17:29:18.359]   - Field: 'envir'
[17:29:18.359]   - Field: 'workers'
[17:29:18.360]   - Field: 'packages'
[17:29:18.360]   - Field: 'gc'
[17:29:18.360]   - Field: 'conditions'
[17:29:18.360]   - Field: 'persistent'
[17:29:18.360]   - Field: 'expr'
[17:29:18.361]   - Field: 'uuid'
[17:29:18.361]   - Field: 'seed'
[17:29:18.361]   - Field: 'version'
[17:29:18.361]   - Field: 'result'
[17:29:18.361]   - Field: 'asynchronous'
[17:29:18.361]   - Field: 'calls'
[17:29:18.362]   - Field: 'globals'
[17:29:18.362]   - Field: 'stdout'
[17:29:18.362]   - Field: 'earlySignal'
[17:29:18.362]   - Field: 'lazy'
[17:29:18.363]   - Field: 'state'
[17:29:18.363] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:18.363] - Launch lazy future ...
[17:29:18.364] Packages needed by the future expression (n = 0): <none>
[17:29:18.364] Packages needed by future strategies (n = 0): <none>
[17:29:18.365] {
[17:29:18.365]     {
[17:29:18.365]         {
[17:29:18.365]             ...future.startTime <- base::Sys.time()
[17:29:18.365]             {
[17:29:18.365]                 {
[17:29:18.365]                   {
[17:29:18.365]                     {
[17:29:18.365]                       base::local({
[17:29:18.365]                         has_future <- base::requireNamespace("future", 
[17:29:18.365]                           quietly = TRUE)
[17:29:18.365]                         if (has_future) {
[17:29:18.365]                           ns <- base::getNamespace("future")
[17:29:18.365]                           version <- ns[[".package"]][["version"]]
[17:29:18.365]                           if (is.null(version)) 
[17:29:18.365]                             version <- utils::packageVersion("future")
[17:29:18.365]                         }
[17:29:18.365]                         else {
[17:29:18.365]                           version <- NULL
[17:29:18.365]                         }
[17:29:18.365]                         if (!has_future || version < "1.8.0") {
[17:29:18.365]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:18.365]                             "", base::R.version$version.string), 
[17:29:18.365]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:18.365]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:18.365]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:18.365]                               "release", "version")], collapse = " "), 
[17:29:18.365]                             hostname = base::Sys.info()[["nodename"]])
[17:29:18.365]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:18.365]                             info)
[17:29:18.365]                           info <- base::paste(info, collapse = "; ")
[17:29:18.365]                           if (!has_future) {
[17:29:18.365]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:18.365]                               info)
[17:29:18.365]                           }
[17:29:18.365]                           else {
[17:29:18.365]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:18.365]                               info, version)
[17:29:18.365]                           }
[17:29:18.365]                           base::stop(msg)
[17:29:18.365]                         }
[17:29:18.365]                       })
[17:29:18.365]                     }
[17:29:18.365]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:18.365]                     base::options(mc.cores = 1L)
[17:29:18.365]                   }
[17:29:18.365]                   ...future.strategy.old <- future::plan("list")
[17:29:18.365]                   options(future.plan = NULL)
[17:29:18.365]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:18.365]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:18.365]                 }
[17:29:18.365]                 ...future.workdir <- getwd()
[17:29:18.365]             }
[17:29:18.365]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:18.365]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:18.365]         }
[17:29:18.365]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:18.365]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:18.365]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:18.365]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:18.365]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:18.365]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:18.365]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:18.365]             base::names(...future.oldOptions))
[17:29:18.365]     }
[17:29:18.365]     if (FALSE) {
[17:29:18.365]     }
[17:29:18.365]     else {
[17:29:18.365]         if (TRUE) {
[17:29:18.365]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:18.365]                 open = "w")
[17:29:18.365]         }
[17:29:18.365]         else {
[17:29:18.365]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:18.365]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:18.365]         }
[17:29:18.365]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:18.365]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:18.365]             base::sink(type = "output", split = FALSE)
[17:29:18.365]             base::close(...future.stdout)
[17:29:18.365]         }, add = TRUE)
[17:29:18.365]     }
[17:29:18.365]     ...future.frame <- base::sys.nframe()
[17:29:18.365]     ...future.conditions <- base::list()
[17:29:18.365]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:18.365]     if (FALSE) {
[17:29:18.365]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:18.365]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:18.365]     }
[17:29:18.365]     ...future.result <- base::tryCatch({
[17:29:18.365]         base::withCallingHandlers({
[17:29:18.365]             ...future.value <- base::withVisible(base::local({
[17:29:18.365]                 ...future.makeSendCondition <- base::local({
[17:29:18.365]                   sendCondition <- NULL
[17:29:18.365]                   function(frame = 1L) {
[17:29:18.365]                     if (is.function(sendCondition)) 
[17:29:18.365]                       return(sendCondition)
[17:29:18.365]                     ns <- getNamespace("parallel")
[17:29:18.365]                     if (exists("sendData", mode = "function", 
[17:29:18.365]                       envir = ns)) {
[17:29:18.365]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:18.365]                         envir = ns)
[17:29:18.365]                       envir <- sys.frame(frame)
[17:29:18.365]                       master <- NULL
[17:29:18.365]                       while (!identical(envir, .GlobalEnv) && 
[17:29:18.365]                         !identical(envir, emptyenv())) {
[17:29:18.365]                         if (exists("master", mode = "list", envir = envir, 
[17:29:18.365]                           inherits = FALSE)) {
[17:29:18.365]                           master <- get("master", mode = "list", 
[17:29:18.365]                             envir = envir, inherits = FALSE)
[17:29:18.365]                           if (inherits(master, c("SOCKnode", 
[17:29:18.365]                             "SOCK0node"))) {
[17:29:18.365]                             sendCondition <<- function(cond) {
[17:29:18.365]                               data <- list(type = "VALUE", value = cond, 
[17:29:18.365]                                 success = TRUE)
[17:29:18.365]                               parallel_sendData(master, data)
[17:29:18.365]                             }
[17:29:18.365]                             return(sendCondition)
[17:29:18.365]                           }
[17:29:18.365]                         }
[17:29:18.365]                         frame <- frame + 1L
[17:29:18.365]                         envir <- sys.frame(frame)
[17:29:18.365]                       }
[17:29:18.365]                     }
[17:29:18.365]                     sendCondition <<- function(cond) NULL
[17:29:18.365]                   }
[17:29:18.365]                 })
[17:29:18.365]                 withCallingHandlers({
[17:29:18.365]                   list(a = 1, b = 42L, c = stop("Nah!"))
[17:29:18.365]                 }, immediateCondition = function(cond) {
[17:29:18.365]                   sendCondition <- ...future.makeSendCondition()
[17:29:18.365]                   sendCondition(cond)
[17:29:18.365]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:18.365]                   {
[17:29:18.365]                     inherits <- base::inherits
[17:29:18.365]                     invokeRestart <- base::invokeRestart
[17:29:18.365]                     is.null <- base::is.null
[17:29:18.365]                     muffled <- FALSE
[17:29:18.365]                     if (inherits(cond, "message")) {
[17:29:18.365]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:18.365]                       if (muffled) 
[17:29:18.365]                         invokeRestart("muffleMessage")
[17:29:18.365]                     }
[17:29:18.365]                     else if (inherits(cond, "warning")) {
[17:29:18.365]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:18.365]                       if (muffled) 
[17:29:18.365]                         invokeRestart("muffleWarning")
[17:29:18.365]                     }
[17:29:18.365]                     else if (inherits(cond, "condition")) {
[17:29:18.365]                       if (!is.null(pattern)) {
[17:29:18.365]                         computeRestarts <- base::computeRestarts
[17:29:18.365]                         grepl <- base::grepl
[17:29:18.365]                         restarts <- computeRestarts(cond)
[17:29:18.365]                         for (restart in restarts) {
[17:29:18.365]                           name <- restart$name
[17:29:18.365]                           if (is.null(name)) 
[17:29:18.365]                             next
[17:29:18.365]                           if (!grepl(pattern, name)) 
[17:29:18.365]                             next
[17:29:18.365]                           invokeRestart(restart)
[17:29:18.365]                           muffled <- TRUE
[17:29:18.365]                           break
[17:29:18.365]                         }
[17:29:18.365]                       }
[17:29:18.365]                     }
[17:29:18.365]                     invisible(muffled)
[17:29:18.365]                   }
[17:29:18.365]                   muffleCondition(cond)
[17:29:18.365]                 })
[17:29:18.365]             }))
[17:29:18.365]             future::FutureResult(value = ...future.value$value, 
[17:29:18.365]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:18.365]                   ...future.rng), globalenv = if (FALSE) 
[17:29:18.365]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:18.365]                     ...future.globalenv.names))
[17:29:18.365]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:18.365]         }, condition = base::local({
[17:29:18.365]             c <- base::c
[17:29:18.365]             inherits <- base::inherits
[17:29:18.365]             invokeRestart <- base::invokeRestart
[17:29:18.365]             length <- base::length
[17:29:18.365]             list <- base::list
[17:29:18.365]             seq.int <- base::seq.int
[17:29:18.365]             signalCondition <- base::signalCondition
[17:29:18.365]             sys.calls <- base::sys.calls
[17:29:18.365]             `[[` <- base::`[[`
[17:29:18.365]             `+` <- base::`+`
[17:29:18.365]             `<<-` <- base::`<<-`
[17:29:18.365]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:18.365]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:18.365]                   3L)]
[17:29:18.365]             }
[17:29:18.365]             function(cond) {
[17:29:18.365]                 is_error <- inherits(cond, "error")
[17:29:18.365]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:18.365]                   NULL)
[17:29:18.365]                 if (is_error) {
[17:29:18.365]                   sessionInformation <- function() {
[17:29:18.365]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:18.365]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:18.365]                       search = base::search(), system = base::Sys.info())
[17:29:18.365]                   }
[17:29:18.365]                   ...future.conditions[[length(...future.conditions) + 
[17:29:18.365]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:18.365]                     cond$call), session = sessionInformation(), 
[17:29:18.365]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:18.365]                   signalCondition(cond)
[17:29:18.365]                 }
[17:29:18.365]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:18.365]                 "immediateCondition"))) {
[17:29:18.365]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:18.365]                   ...future.conditions[[length(...future.conditions) + 
[17:29:18.365]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:18.365]                   if (TRUE && !signal) {
[17:29:18.365]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:18.365]                     {
[17:29:18.365]                       inherits <- base::inherits
[17:29:18.365]                       invokeRestart <- base::invokeRestart
[17:29:18.365]                       is.null <- base::is.null
[17:29:18.365]                       muffled <- FALSE
[17:29:18.365]                       if (inherits(cond, "message")) {
[17:29:18.365]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:18.365]                         if (muffled) 
[17:29:18.365]                           invokeRestart("muffleMessage")
[17:29:18.365]                       }
[17:29:18.365]                       else if (inherits(cond, "warning")) {
[17:29:18.365]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:18.365]                         if (muffled) 
[17:29:18.365]                           invokeRestart("muffleWarning")
[17:29:18.365]                       }
[17:29:18.365]                       else if (inherits(cond, "condition")) {
[17:29:18.365]                         if (!is.null(pattern)) {
[17:29:18.365]                           computeRestarts <- base::computeRestarts
[17:29:18.365]                           grepl <- base::grepl
[17:29:18.365]                           restarts <- computeRestarts(cond)
[17:29:18.365]                           for (restart in restarts) {
[17:29:18.365]                             name <- restart$name
[17:29:18.365]                             if (is.null(name)) 
[17:29:18.365]                               next
[17:29:18.365]                             if (!grepl(pattern, name)) 
[17:29:18.365]                               next
[17:29:18.365]                             invokeRestart(restart)
[17:29:18.365]                             muffled <- TRUE
[17:29:18.365]                             break
[17:29:18.365]                           }
[17:29:18.365]                         }
[17:29:18.365]                       }
[17:29:18.365]                       invisible(muffled)
[17:29:18.365]                     }
[17:29:18.365]                     muffleCondition(cond, pattern = "^muffle")
[17:29:18.365]                   }
[17:29:18.365]                 }
[17:29:18.365]                 else {
[17:29:18.365]                   if (TRUE) {
[17:29:18.365]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:18.365]                     {
[17:29:18.365]                       inherits <- base::inherits
[17:29:18.365]                       invokeRestart <- base::invokeRestart
[17:29:18.365]                       is.null <- base::is.null
[17:29:18.365]                       muffled <- FALSE
[17:29:18.365]                       if (inherits(cond, "message")) {
[17:29:18.365]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:18.365]                         if (muffled) 
[17:29:18.365]                           invokeRestart("muffleMessage")
[17:29:18.365]                       }
[17:29:18.365]                       else if (inherits(cond, "warning")) {
[17:29:18.365]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:18.365]                         if (muffled) 
[17:29:18.365]                           invokeRestart("muffleWarning")
[17:29:18.365]                       }
[17:29:18.365]                       else if (inherits(cond, "condition")) {
[17:29:18.365]                         if (!is.null(pattern)) {
[17:29:18.365]                           computeRestarts <- base::computeRestarts
[17:29:18.365]                           grepl <- base::grepl
[17:29:18.365]                           restarts <- computeRestarts(cond)
[17:29:18.365]                           for (restart in restarts) {
[17:29:18.365]                             name <- restart$name
[17:29:18.365]                             if (is.null(name)) 
[17:29:18.365]                               next
[17:29:18.365]                             if (!grepl(pattern, name)) 
[17:29:18.365]                               next
[17:29:18.365]                             invokeRestart(restart)
[17:29:18.365]                             muffled <- TRUE
[17:29:18.365]                             break
[17:29:18.365]                           }
[17:29:18.365]                         }
[17:29:18.365]                       }
[17:29:18.365]                       invisible(muffled)
[17:29:18.365]                     }
[17:29:18.365]                     muffleCondition(cond, pattern = "^muffle")
[17:29:18.365]                   }
[17:29:18.365]                 }
[17:29:18.365]             }
[17:29:18.365]         }))
[17:29:18.365]     }, error = function(ex) {
[17:29:18.365]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:18.365]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:18.365]                 ...future.rng), started = ...future.startTime, 
[17:29:18.365]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:18.365]             version = "1.8"), class = "FutureResult")
[17:29:18.365]     }, finally = {
[17:29:18.365]         if (!identical(...future.workdir, getwd())) 
[17:29:18.365]             setwd(...future.workdir)
[17:29:18.365]         {
[17:29:18.365]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:18.365]                 ...future.oldOptions$nwarnings <- NULL
[17:29:18.365]             }
[17:29:18.365]             base::options(...future.oldOptions)
[17:29:18.365]             if (.Platform$OS.type == "windows") {
[17:29:18.365]                 old_names <- names(...future.oldEnvVars)
[17:29:18.365]                 envs <- base::Sys.getenv()
[17:29:18.365]                 names <- names(envs)
[17:29:18.365]                 common <- intersect(names, old_names)
[17:29:18.365]                 added <- setdiff(names, old_names)
[17:29:18.365]                 removed <- setdiff(old_names, names)
[17:29:18.365]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:18.365]                   envs[common]]
[17:29:18.365]                 NAMES <- toupper(changed)
[17:29:18.365]                 args <- list()
[17:29:18.365]                 for (kk in seq_along(NAMES)) {
[17:29:18.365]                   name <- changed[[kk]]
[17:29:18.365]                   NAME <- NAMES[[kk]]
[17:29:18.365]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:18.365]                     next
[17:29:18.365]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:18.365]                 }
[17:29:18.365]                 NAMES <- toupper(added)
[17:29:18.365]                 for (kk in seq_along(NAMES)) {
[17:29:18.365]                   name <- added[[kk]]
[17:29:18.365]                   NAME <- NAMES[[kk]]
[17:29:18.365]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:18.365]                     next
[17:29:18.365]                   args[[name]] <- ""
[17:29:18.365]                 }
[17:29:18.365]                 NAMES <- toupper(removed)
[17:29:18.365]                 for (kk in seq_along(NAMES)) {
[17:29:18.365]                   name <- removed[[kk]]
[17:29:18.365]                   NAME <- NAMES[[kk]]
[17:29:18.365]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:18.365]                     next
[17:29:18.365]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:18.365]                 }
[17:29:18.365]                 if (length(args) > 0) 
[17:29:18.365]                   base::do.call(base::Sys.setenv, args = args)
[17:29:18.365]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:18.365]             }
[17:29:18.365]             else {
[17:29:18.365]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:18.365]             }
[17:29:18.365]             {
[17:29:18.365]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:18.365]                   0L) {
[17:29:18.365]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:18.365]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:18.365]                   base::options(opts)
[17:29:18.365]                 }
[17:29:18.365]                 {
[17:29:18.365]                   {
[17:29:18.365]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:18.365]                     NULL
[17:29:18.365]                   }
[17:29:18.365]                   options(future.plan = NULL)
[17:29:18.365]                   if (is.na(NA_character_)) 
[17:29:18.365]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:18.365]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:18.365]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:18.365]                     .init = FALSE)
[17:29:18.365]                 }
[17:29:18.365]             }
[17:29:18.365]         }
[17:29:18.365]     })
[17:29:18.365]     if (TRUE) {
[17:29:18.365]         base::sink(type = "output", split = FALSE)
[17:29:18.365]         if (TRUE) {
[17:29:18.365]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:18.365]         }
[17:29:18.365]         else {
[17:29:18.365]             ...future.result["stdout"] <- base::list(NULL)
[17:29:18.365]         }
[17:29:18.365]         base::close(...future.stdout)
[17:29:18.365]         ...future.stdout <- NULL
[17:29:18.365]     }
[17:29:18.365]     ...future.result$conditions <- ...future.conditions
[17:29:18.365]     ...future.result$finished <- base::Sys.time()
[17:29:18.365]     ...future.result
[17:29:18.365] }
[17:29:18.374] MultisessionFuture started
[17:29:18.375] - Launch lazy future ... done
[17:29:18.375] run() for 'MultisessionFuture' ... done
[17:29:18.401] receiveMessageFromWorker() for ClusterFuture ...
[17:29:18.401] - Validating connection of MultisessionFuture
[17:29:18.402] - received message: FutureResult
[17:29:18.402] - Received FutureResult
[17:29:18.403] - Erased future from FutureRegistry
[17:29:18.403] result() for ClusterFuture ...
[17:29:18.403] - result already collected: FutureResult
[17:29:18.403] result() for ClusterFuture ... done
[17:29:18.403] signalConditions() ...
[17:29:18.403]  - include = 'immediateCondition'
[17:29:18.404]  - exclude = 
[17:29:18.404]  - resignal = FALSE
[17:29:18.404]  - Number of conditions: 1
[17:29:18.404] signalConditions() ... done
[17:29:18.404] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:18.405] A MultisessionFuture was resolved (and resolved itself)
- result = TRUE, recursive = TRUE ... DONE
- result = TRUE, recursive = -1 ...
[17:29:18.405] getGlobalsAndPackages() ...
[17:29:18.405] Searching for globals...
[17:29:18.407] - globals found: [3] '{', 'Sys.sleep', 'list'
[17:29:18.407] Searching for globals ... DONE
[17:29:18.407] Resolving globals: FALSE
[17:29:18.408] 
[17:29:18.408] 
[17:29:18.408] getGlobalsAndPackages() ... DONE
[17:29:18.408] run() for 'Future' ...
[17:29:18.409] - state: 'created'
[17:29:18.409] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:18.428] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:18.428] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:18.428]   - Field: 'node'
[17:29:18.429]   - Field: 'label'
[17:29:18.429]   - Field: 'local'
[17:29:18.429]   - Field: 'owner'
[17:29:18.429]   - Field: 'envir'
[17:29:18.429]   - Field: 'workers'
[17:29:18.430]   - Field: 'packages'
[17:29:18.430]   - Field: 'gc'
[17:29:18.430]   - Field: 'conditions'
[17:29:18.430]   - Field: 'persistent'
[17:29:18.430]   - Field: 'expr'
[17:29:18.430]   - Field: 'uuid'
[17:29:18.431]   - Field: 'seed'
[17:29:18.431]   - Field: 'version'
[17:29:18.431]   - Field: 'result'
[17:29:18.431]   - Field: 'asynchronous'
[17:29:18.431]   - Field: 'calls'
[17:29:18.432]   - Field: 'globals'
[17:29:18.432]   - Field: 'stdout'
[17:29:18.432]   - Field: 'earlySignal'
[17:29:18.432]   - Field: 'lazy'
[17:29:18.432]   - Field: 'state'
[17:29:18.432] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:18.433] - Launch lazy future ...
[17:29:18.433] Packages needed by the future expression (n = 0): <none>
[17:29:18.433] Packages needed by future strategies (n = 0): <none>
[17:29:18.434] {
[17:29:18.434]     {
[17:29:18.434]         {
[17:29:18.434]             ...future.startTime <- base::Sys.time()
[17:29:18.434]             {
[17:29:18.434]                 {
[17:29:18.434]                   {
[17:29:18.434]                     {
[17:29:18.434]                       base::local({
[17:29:18.434]                         has_future <- base::requireNamespace("future", 
[17:29:18.434]                           quietly = TRUE)
[17:29:18.434]                         if (has_future) {
[17:29:18.434]                           ns <- base::getNamespace("future")
[17:29:18.434]                           version <- ns[[".package"]][["version"]]
[17:29:18.434]                           if (is.null(version)) 
[17:29:18.434]                             version <- utils::packageVersion("future")
[17:29:18.434]                         }
[17:29:18.434]                         else {
[17:29:18.434]                           version <- NULL
[17:29:18.434]                         }
[17:29:18.434]                         if (!has_future || version < "1.8.0") {
[17:29:18.434]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:18.434]                             "", base::R.version$version.string), 
[17:29:18.434]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:18.434]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:18.434]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:18.434]                               "release", "version")], collapse = " "), 
[17:29:18.434]                             hostname = base::Sys.info()[["nodename"]])
[17:29:18.434]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:18.434]                             info)
[17:29:18.434]                           info <- base::paste(info, collapse = "; ")
[17:29:18.434]                           if (!has_future) {
[17:29:18.434]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:18.434]                               info)
[17:29:18.434]                           }
[17:29:18.434]                           else {
[17:29:18.434]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:18.434]                               info, version)
[17:29:18.434]                           }
[17:29:18.434]                           base::stop(msg)
[17:29:18.434]                         }
[17:29:18.434]                       })
[17:29:18.434]                     }
[17:29:18.434]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:18.434]                     base::options(mc.cores = 1L)
[17:29:18.434]                   }
[17:29:18.434]                   ...future.strategy.old <- future::plan("list")
[17:29:18.434]                   options(future.plan = NULL)
[17:29:18.434]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:18.434]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:18.434]                 }
[17:29:18.434]                 ...future.workdir <- getwd()
[17:29:18.434]             }
[17:29:18.434]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:18.434]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:18.434]         }
[17:29:18.434]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:18.434]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:18.434]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:18.434]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:18.434]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:18.434]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:18.434]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:18.434]             base::names(...future.oldOptions))
[17:29:18.434]     }
[17:29:18.434]     if (FALSE) {
[17:29:18.434]     }
[17:29:18.434]     else {
[17:29:18.434]         if (TRUE) {
[17:29:18.434]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:18.434]                 open = "w")
[17:29:18.434]         }
[17:29:18.434]         else {
[17:29:18.434]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:18.434]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:18.434]         }
[17:29:18.434]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:18.434]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:18.434]             base::sink(type = "output", split = FALSE)
[17:29:18.434]             base::close(...future.stdout)
[17:29:18.434]         }, add = TRUE)
[17:29:18.434]     }
[17:29:18.434]     ...future.frame <- base::sys.nframe()
[17:29:18.434]     ...future.conditions <- base::list()
[17:29:18.434]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:18.434]     if (FALSE) {
[17:29:18.434]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:18.434]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:18.434]     }
[17:29:18.434]     ...future.result <- base::tryCatch({
[17:29:18.434]         base::withCallingHandlers({
[17:29:18.434]             ...future.value <- base::withVisible(base::local({
[17:29:18.434]                 ...future.makeSendCondition <- base::local({
[17:29:18.434]                   sendCondition <- NULL
[17:29:18.434]                   function(frame = 1L) {
[17:29:18.434]                     if (is.function(sendCondition)) 
[17:29:18.434]                       return(sendCondition)
[17:29:18.434]                     ns <- getNamespace("parallel")
[17:29:18.434]                     if (exists("sendData", mode = "function", 
[17:29:18.434]                       envir = ns)) {
[17:29:18.434]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:18.434]                         envir = ns)
[17:29:18.434]                       envir <- sys.frame(frame)
[17:29:18.434]                       master <- NULL
[17:29:18.434]                       while (!identical(envir, .GlobalEnv) && 
[17:29:18.434]                         !identical(envir, emptyenv())) {
[17:29:18.434]                         if (exists("master", mode = "list", envir = envir, 
[17:29:18.434]                           inherits = FALSE)) {
[17:29:18.434]                           master <- get("master", mode = "list", 
[17:29:18.434]                             envir = envir, inherits = FALSE)
[17:29:18.434]                           if (inherits(master, c("SOCKnode", 
[17:29:18.434]                             "SOCK0node"))) {
[17:29:18.434]                             sendCondition <<- function(cond) {
[17:29:18.434]                               data <- list(type = "VALUE", value = cond, 
[17:29:18.434]                                 success = TRUE)
[17:29:18.434]                               parallel_sendData(master, data)
[17:29:18.434]                             }
[17:29:18.434]                             return(sendCondition)
[17:29:18.434]                           }
[17:29:18.434]                         }
[17:29:18.434]                         frame <- frame + 1L
[17:29:18.434]                         envir <- sys.frame(frame)
[17:29:18.434]                       }
[17:29:18.434]                     }
[17:29:18.434]                     sendCondition <<- function(cond) NULL
[17:29:18.434]                   }
[17:29:18.434]                 })
[17:29:18.434]                 withCallingHandlers({
[17:29:18.434]                   {
[17:29:18.434]                     Sys.sleep(0.5)
[17:29:18.434]                     list(a = 1, b = 42L)
[17:29:18.434]                   }
[17:29:18.434]                 }, immediateCondition = function(cond) {
[17:29:18.434]                   sendCondition <- ...future.makeSendCondition()
[17:29:18.434]                   sendCondition(cond)
[17:29:18.434]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:18.434]                   {
[17:29:18.434]                     inherits <- base::inherits
[17:29:18.434]                     invokeRestart <- base::invokeRestart
[17:29:18.434]                     is.null <- base::is.null
[17:29:18.434]                     muffled <- FALSE
[17:29:18.434]                     if (inherits(cond, "message")) {
[17:29:18.434]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:18.434]                       if (muffled) 
[17:29:18.434]                         invokeRestart("muffleMessage")
[17:29:18.434]                     }
[17:29:18.434]                     else if (inherits(cond, "warning")) {
[17:29:18.434]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:18.434]                       if (muffled) 
[17:29:18.434]                         invokeRestart("muffleWarning")
[17:29:18.434]                     }
[17:29:18.434]                     else if (inherits(cond, "condition")) {
[17:29:18.434]                       if (!is.null(pattern)) {
[17:29:18.434]                         computeRestarts <- base::computeRestarts
[17:29:18.434]                         grepl <- base::grepl
[17:29:18.434]                         restarts <- computeRestarts(cond)
[17:29:18.434]                         for (restart in restarts) {
[17:29:18.434]                           name <- restart$name
[17:29:18.434]                           if (is.null(name)) 
[17:29:18.434]                             next
[17:29:18.434]                           if (!grepl(pattern, name)) 
[17:29:18.434]                             next
[17:29:18.434]                           invokeRestart(restart)
[17:29:18.434]                           muffled <- TRUE
[17:29:18.434]                           break
[17:29:18.434]                         }
[17:29:18.434]                       }
[17:29:18.434]                     }
[17:29:18.434]                     invisible(muffled)
[17:29:18.434]                   }
[17:29:18.434]                   muffleCondition(cond)
[17:29:18.434]                 })
[17:29:18.434]             }))
[17:29:18.434]             future::FutureResult(value = ...future.value$value, 
[17:29:18.434]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:18.434]                   ...future.rng), globalenv = if (FALSE) 
[17:29:18.434]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:18.434]                     ...future.globalenv.names))
[17:29:18.434]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:18.434]         }, condition = base::local({
[17:29:18.434]             c <- base::c
[17:29:18.434]             inherits <- base::inherits
[17:29:18.434]             invokeRestart <- base::invokeRestart
[17:29:18.434]             length <- base::length
[17:29:18.434]             list <- base::list
[17:29:18.434]             seq.int <- base::seq.int
[17:29:18.434]             signalCondition <- base::signalCondition
[17:29:18.434]             sys.calls <- base::sys.calls
[17:29:18.434]             `[[` <- base::`[[`
[17:29:18.434]             `+` <- base::`+`
[17:29:18.434]             `<<-` <- base::`<<-`
[17:29:18.434]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:18.434]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:18.434]                   3L)]
[17:29:18.434]             }
[17:29:18.434]             function(cond) {
[17:29:18.434]                 is_error <- inherits(cond, "error")
[17:29:18.434]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:18.434]                   NULL)
[17:29:18.434]                 if (is_error) {
[17:29:18.434]                   sessionInformation <- function() {
[17:29:18.434]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:18.434]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:18.434]                       search = base::search(), system = base::Sys.info())
[17:29:18.434]                   }
[17:29:18.434]                   ...future.conditions[[length(...future.conditions) + 
[17:29:18.434]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:18.434]                     cond$call), session = sessionInformation(), 
[17:29:18.434]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:18.434]                   signalCondition(cond)
[17:29:18.434]                 }
[17:29:18.434]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:18.434]                 "immediateCondition"))) {
[17:29:18.434]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:18.434]                   ...future.conditions[[length(...future.conditions) + 
[17:29:18.434]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:18.434]                   if (TRUE && !signal) {
[17:29:18.434]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:18.434]                     {
[17:29:18.434]                       inherits <- base::inherits
[17:29:18.434]                       invokeRestart <- base::invokeRestart
[17:29:18.434]                       is.null <- base::is.null
[17:29:18.434]                       muffled <- FALSE
[17:29:18.434]                       if (inherits(cond, "message")) {
[17:29:18.434]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:18.434]                         if (muffled) 
[17:29:18.434]                           invokeRestart("muffleMessage")
[17:29:18.434]                       }
[17:29:18.434]                       else if (inherits(cond, "warning")) {
[17:29:18.434]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:18.434]                         if (muffled) 
[17:29:18.434]                           invokeRestart("muffleWarning")
[17:29:18.434]                       }
[17:29:18.434]                       else if (inherits(cond, "condition")) {
[17:29:18.434]                         if (!is.null(pattern)) {
[17:29:18.434]                           computeRestarts <- base::computeRestarts
[17:29:18.434]                           grepl <- base::grepl
[17:29:18.434]                           restarts <- computeRestarts(cond)
[17:29:18.434]                           for (restart in restarts) {
[17:29:18.434]                             name <- restart$name
[17:29:18.434]                             if (is.null(name)) 
[17:29:18.434]                               next
[17:29:18.434]                             if (!grepl(pattern, name)) 
[17:29:18.434]                               next
[17:29:18.434]                             invokeRestart(restart)
[17:29:18.434]                             muffled <- TRUE
[17:29:18.434]                             break
[17:29:18.434]                           }
[17:29:18.434]                         }
[17:29:18.434]                       }
[17:29:18.434]                       invisible(muffled)
[17:29:18.434]                     }
[17:29:18.434]                     muffleCondition(cond, pattern = "^muffle")
[17:29:18.434]                   }
[17:29:18.434]                 }
[17:29:18.434]                 else {
[17:29:18.434]                   if (TRUE) {
[17:29:18.434]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:18.434]                     {
[17:29:18.434]                       inherits <- base::inherits
[17:29:18.434]                       invokeRestart <- base::invokeRestart
[17:29:18.434]                       is.null <- base::is.null
[17:29:18.434]                       muffled <- FALSE
[17:29:18.434]                       if (inherits(cond, "message")) {
[17:29:18.434]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:18.434]                         if (muffled) 
[17:29:18.434]                           invokeRestart("muffleMessage")
[17:29:18.434]                       }
[17:29:18.434]                       else if (inherits(cond, "warning")) {
[17:29:18.434]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:18.434]                         if (muffled) 
[17:29:18.434]                           invokeRestart("muffleWarning")
[17:29:18.434]                       }
[17:29:18.434]                       else if (inherits(cond, "condition")) {
[17:29:18.434]                         if (!is.null(pattern)) {
[17:29:18.434]                           computeRestarts <- base::computeRestarts
[17:29:18.434]                           grepl <- base::grepl
[17:29:18.434]                           restarts <- computeRestarts(cond)
[17:29:18.434]                           for (restart in restarts) {
[17:29:18.434]                             name <- restart$name
[17:29:18.434]                             if (is.null(name)) 
[17:29:18.434]                               next
[17:29:18.434]                             if (!grepl(pattern, name)) 
[17:29:18.434]                               next
[17:29:18.434]                             invokeRestart(restart)
[17:29:18.434]                             muffled <- TRUE
[17:29:18.434]                             break
[17:29:18.434]                           }
[17:29:18.434]                         }
[17:29:18.434]                       }
[17:29:18.434]                       invisible(muffled)
[17:29:18.434]                     }
[17:29:18.434]                     muffleCondition(cond, pattern = "^muffle")
[17:29:18.434]                   }
[17:29:18.434]                 }
[17:29:18.434]             }
[17:29:18.434]         }))
[17:29:18.434]     }, error = function(ex) {
[17:29:18.434]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:18.434]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:18.434]                 ...future.rng), started = ...future.startTime, 
[17:29:18.434]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:18.434]             version = "1.8"), class = "FutureResult")
[17:29:18.434]     }, finally = {
[17:29:18.434]         if (!identical(...future.workdir, getwd())) 
[17:29:18.434]             setwd(...future.workdir)
[17:29:18.434]         {
[17:29:18.434]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:18.434]                 ...future.oldOptions$nwarnings <- NULL
[17:29:18.434]             }
[17:29:18.434]             base::options(...future.oldOptions)
[17:29:18.434]             if (.Platform$OS.type == "windows") {
[17:29:18.434]                 old_names <- names(...future.oldEnvVars)
[17:29:18.434]                 envs <- base::Sys.getenv()
[17:29:18.434]                 names <- names(envs)
[17:29:18.434]                 common <- intersect(names, old_names)
[17:29:18.434]                 added <- setdiff(names, old_names)
[17:29:18.434]                 removed <- setdiff(old_names, names)
[17:29:18.434]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:18.434]                   envs[common]]
[17:29:18.434]                 NAMES <- toupper(changed)
[17:29:18.434]                 args <- list()
[17:29:18.434]                 for (kk in seq_along(NAMES)) {
[17:29:18.434]                   name <- changed[[kk]]
[17:29:18.434]                   NAME <- NAMES[[kk]]
[17:29:18.434]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:18.434]                     next
[17:29:18.434]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:18.434]                 }
[17:29:18.434]                 NAMES <- toupper(added)
[17:29:18.434]                 for (kk in seq_along(NAMES)) {
[17:29:18.434]                   name <- added[[kk]]
[17:29:18.434]                   NAME <- NAMES[[kk]]
[17:29:18.434]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:18.434]                     next
[17:29:18.434]                   args[[name]] <- ""
[17:29:18.434]                 }
[17:29:18.434]                 NAMES <- toupper(removed)
[17:29:18.434]                 for (kk in seq_along(NAMES)) {
[17:29:18.434]                   name <- removed[[kk]]
[17:29:18.434]                   NAME <- NAMES[[kk]]
[17:29:18.434]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:18.434]                     next
[17:29:18.434]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:18.434]                 }
[17:29:18.434]                 if (length(args) > 0) 
[17:29:18.434]                   base::do.call(base::Sys.setenv, args = args)
[17:29:18.434]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:18.434]             }
[17:29:18.434]             else {
[17:29:18.434]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:18.434]             }
[17:29:18.434]             {
[17:29:18.434]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:18.434]                   0L) {
[17:29:18.434]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:18.434]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:18.434]                   base::options(opts)
[17:29:18.434]                 }
[17:29:18.434]                 {
[17:29:18.434]                   {
[17:29:18.434]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:18.434]                     NULL
[17:29:18.434]                   }
[17:29:18.434]                   options(future.plan = NULL)
[17:29:18.434]                   if (is.na(NA_character_)) 
[17:29:18.434]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:18.434]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:18.434]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:18.434]                     .init = FALSE)
[17:29:18.434]                 }
[17:29:18.434]             }
[17:29:18.434]         }
[17:29:18.434]     })
[17:29:18.434]     if (TRUE) {
[17:29:18.434]         base::sink(type = "output", split = FALSE)
[17:29:18.434]         if (TRUE) {
[17:29:18.434]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:18.434]         }
[17:29:18.434]         else {
[17:29:18.434]             ...future.result["stdout"] <- base::list(NULL)
[17:29:18.434]         }
[17:29:18.434]         base::close(...future.stdout)
[17:29:18.434]         ...future.stdout <- NULL
[17:29:18.434]     }
[17:29:18.434]     ...future.result$conditions <- ...future.conditions
[17:29:18.434]     ...future.result$finished <- base::Sys.time()
[17:29:18.434]     ...future.result
[17:29:18.434] }
[17:29:18.440] MultisessionFuture started
[17:29:18.440] - Launch lazy future ... done
[17:29:18.441] run() for 'MultisessionFuture' ... done
[17:29:18.441] getGlobalsAndPackages() ...
[17:29:18.441] Searching for globals...
[17:29:18.444] - globals found: [3] '{', 'Sys.sleep', 'list'
[17:29:18.444] Searching for globals ... DONE
[17:29:18.444] Resolving globals: FALSE
[17:29:18.445] 
[17:29:18.445] 
[17:29:18.446] getGlobalsAndPackages() ... DONE
- w/ exception ...
[17:29:18.446] getGlobalsAndPackages() ...
[17:29:18.447] Searching for globals...
[17:29:18.448] - globals found: [2] 'list', 'stop'
[17:29:18.448] Searching for globals ... DONE
[17:29:18.448] Resolving globals: FALSE
[17:29:18.449] 
[17:29:18.449] 
[17:29:18.450] getGlobalsAndPackages() ... DONE
[17:29:18.450] run() for 'Future' ...
[17:29:18.450] - state: 'created'
[17:29:18.451] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:18.468] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:18.469] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:18.469]   - Field: 'node'
[17:29:18.469]   - Field: 'label'
[17:29:18.470]   - Field: 'local'
[17:29:18.470]   - Field: 'owner'
[17:29:18.470]   - Field: 'envir'
[17:29:18.470]   - Field: 'workers'
[17:29:18.471]   - Field: 'packages'
[17:29:18.471]   - Field: 'gc'
[17:29:18.471]   - Field: 'conditions'
[17:29:18.471]   - Field: 'persistent'
[17:29:18.472]   - Field: 'expr'
[17:29:18.472]   - Field: 'uuid'
[17:29:18.472]   - Field: 'seed'
[17:29:18.473]   - Field: 'version'
[17:29:18.473]   - Field: 'result'
[17:29:18.473]   - Field: 'asynchronous'
[17:29:18.474]   - Field: 'calls'
[17:29:18.474]   - Field: 'globals'
[17:29:18.474]   - Field: 'stdout'
[17:29:18.475]   - Field: 'earlySignal'
[17:29:18.479]   - Field: 'lazy'
[17:29:18.479]   - Field: 'state'
[17:29:18.479] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:18.480] - Launch lazy future ...
[17:29:18.480] Packages needed by the future expression (n = 0): <none>
[17:29:18.481] Packages needed by future strategies (n = 0): <none>
[17:29:18.481] {
[17:29:18.481]     {
[17:29:18.481]         {
[17:29:18.481]             ...future.startTime <- base::Sys.time()
[17:29:18.481]             {
[17:29:18.481]                 {
[17:29:18.481]                   {
[17:29:18.481]                     {
[17:29:18.481]                       base::local({
[17:29:18.481]                         has_future <- base::requireNamespace("future", 
[17:29:18.481]                           quietly = TRUE)
[17:29:18.481]                         if (has_future) {
[17:29:18.481]                           ns <- base::getNamespace("future")
[17:29:18.481]                           version <- ns[[".package"]][["version"]]
[17:29:18.481]                           if (is.null(version)) 
[17:29:18.481]                             version <- utils::packageVersion("future")
[17:29:18.481]                         }
[17:29:18.481]                         else {
[17:29:18.481]                           version <- NULL
[17:29:18.481]                         }
[17:29:18.481]                         if (!has_future || version < "1.8.0") {
[17:29:18.481]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:18.481]                             "", base::R.version$version.string), 
[17:29:18.481]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:18.481]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:18.481]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:18.481]                               "release", "version")], collapse = " "), 
[17:29:18.481]                             hostname = base::Sys.info()[["nodename"]])
[17:29:18.481]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:18.481]                             info)
[17:29:18.481]                           info <- base::paste(info, collapse = "; ")
[17:29:18.481]                           if (!has_future) {
[17:29:18.481]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:18.481]                               info)
[17:29:18.481]                           }
[17:29:18.481]                           else {
[17:29:18.481]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:18.481]                               info, version)
[17:29:18.481]                           }
[17:29:18.481]                           base::stop(msg)
[17:29:18.481]                         }
[17:29:18.481]                       })
[17:29:18.481]                     }
[17:29:18.481]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:18.481]                     base::options(mc.cores = 1L)
[17:29:18.481]                   }
[17:29:18.481]                   ...future.strategy.old <- future::plan("list")
[17:29:18.481]                   options(future.plan = NULL)
[17:29:18.481]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:18.481]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:18.481]                 }
[17:29:18.481]                 ...future.workdir <- getwd()
[17:29:18.481]             }
[17:29:18.481]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:18.481]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:18.481]         }
[17:29:18.481]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:18.481]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:18.481]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:18.481]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:18.481]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:18.481]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:18.481]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:18.481]             base::names(...future.oldOptions))
[17:29:18.481]     }
[17:29:18.481]     if (FALSE) {
[17:29:18.481]     }
[17:29:18.481]     else {
[17:29:18.481]         if (TRUE) {
[17:29:18.481]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:18.481]                 open = "w")
[17:29:18.481]         }
[17:29:18.481]         else {
[17:29:18.481]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:18.481]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:18.481]         }
[17:29:18.481]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:18.481]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:18.481]             base::sink(type = "output", split = FALSE)
[17:29:18.481]             base::close(...future.stdout)
[17:29:18.481]         }, add = TRUE)
[17:29:18.481]     }
[17:29:18.481]     ...future.frame <- base::sys.nframe()
[17:29:18.481]     ...future.conditions <- base::list()
[17:29:18.481]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:18.481]     if (FALSE) {
[17:29:18.481]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:18.481]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:18.481]     }
[17:29:18.481]     ...future.result <- base::tryCatch({
[17:29:18.481]         base::withCallingHandlers({
[17:29:18.481]             ...future.value <- base::withVisible(base::local({
[17:29:18.481]                 ...future.makeSendCondition <- base::local({
[17:29:18.481]                   sendCondition <- NULL
[17:29:18.481]                   function(frame = 1L) {
[17:29:18.481]                     if (is.function(sendCondition)) 
[17:29:18.481]                       return(sendCondition)
[17:29:18.481]                     ns <- getNamespace("parallel")
[17:29:18.481]                     if (exists("sendData", mode = "function", 
[17:29:18.481]                       envir = ns)) {
[17:29:18.481]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:18.481]                         envir = ns)
[17:29:18.481]                       envir <- sys.frame(frame)
[17:29:18.481]                       master <- NULL
[17:29:18.481]                       while (!identical(envir, .GlobalEnv) && 
[17:29:18.481]                         !identical(envir, emptyenv())) {
[17:29:18.481]                         if (exists("master", mode = "list", envir = envir, 
[17:29:18.481]                           inherits = FALSE)) {
[17:29:18.481]                           master <- get("master", mode = "list", 
[17:29:18.481]                             envir = envir, inherits = FALSE)
[17:29:18.481]                           if (inherits(master, c("SOCKnode", 
[17:29:18.481]                             "SOCK0node"))) {
[17:29:18.481]                             sendCondition <<- function(cond) {
[17:29:18.481]                               data <- list(type = "VALUE", value = cond, 
[17:29:18.481]                                 success = TRUE)
[17:29:18.481]                               parallel_sendData(master, data)
[17:29:18.481]                             }
[17:29:18.481]                             return(sendCondition)
[17:29:18.481]                           }
[17:29:18.481]                         }
[17:29:18.481]                         frame <- frame + 1L
[17:29:18.481]                         envir <- sys.frame(frame)
[17:29:18.481]                       }
[17:29:18.481]                     }
[17:29:18.481]                     sendCondition <<- function(cond) NULL
[17:29:18.481]                   }
[17:29:18.481]                 })
[17:29:18.481]                 withCallingHandlers({
[17:29:18.481]                   list(a = 1, b = 42L, c = stop("Nah!"))
[17:29:18.481]                 }, immediateCondition = function(cond) {
[17:29:18.481]                   sendCondition <- ...future.makeSendCondition()
[17:29:18.481]                   sendCondition(cond)
[17:29:18.481]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:18.481]                   {
[17:29:18.481]                     inherits <- base::inherits
[17:29:18.481]                     invokeRestart <- base::invokeRestart
[17:29:18.481]                     is.null <- base::is.null
[17:29:18.481]                     muffled <- FALSE
[17:29:18.481]                     if (inherits(cond, "message")) {
[17:29:18.481]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:18.481]                       if (muffled) 
[17:29:18.481]                         invokeRestart("muffleMessage")
[17:29:18.481]                     }
[17:29:18.481]                     else if (inherits(cond, "warning")) {
[17:29:18.481]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:18.481]                       if (muffled) 
[17:29:18.481]                         invokeRestart("muffleWarning")
[17:29:18.481]                     }
[17:29:18.481]                     else if (inherits(cond, "condition")) {
[17:29:18.481]                       if (!is.null(pattern)) {
[17:29:18.481]                         computeRestarts <- base::computeRestarts
[17:29:18.481]                         grepl <- base::grepl
[17:29:18.481]                         restarts <- computeRestarts(cond)
[17:29:18.481]                         for (restart in restarts) {
[17:29:18.481]                           name <- restart$name
[17:29:18.481]                           if (is.null(name)) 
[17:29:18.481]                             next
[17:29:18.481]                           if (!grepl(pattern, name)) 
[17:29:18.481]                             next
[17:29:18.481]                           invokeRestart(restart)
[17:29:18.481]                           muffled <- TRUE
[17:29:18.481]                           break
[17:29:18.481]                         }
[17:29:18.481]                       }
[17:29:18.481]                     }
[17:29:18.481]                     invisible(muffled)
[17:29:18.481]                   }
[17:29:18.481]                   muffleCondition(cond)
[17:29:18.481]                 })
[17:29:18.481]             }))
[17:29:18.481]             future::FutureResult(value = ...future.value$value, 
[17:29:18.481]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:18.481]                   ...future.rng), globalenv = if (FALSE) 
[17:29:18.481]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:18.481]                     ...future.globalenv.names))
[17:29:18.481]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:18.481]         }, condition = base::local({
[17:29:18.481]             c <- base::c
[17:29:18.481]             inherits <- base::inherits
[17:29:18.481]             invokeRestart <- base::invokeRestart
[17:29:18.481]             length <- base::length
[17:29:18.481]             list <- base::list
[17:29:18.481]             seq.int <- base::seq.int
[17:29:18.481]             signalCondition <- base::signalCondition
[17:29:18.481]             sys.calls <- base::sys.calls
[17:29:18.481]             `[[` <- base::`[[`
[17:29:18.481]             `+` <- base::`+`
[17:29:18.481]             `<<-` <- base::`<<-`
[17:29:18.481]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:18.481]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:18.481]                   3L)]
[17:29:18.481]             }
[17:29:18.481]             function(cond) {
[17:29:18.481]                 is_error <- inherits(cond, "error")
[17:29:18.481]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:18.481]                   NULL)
[17:29:18.481]                 if (is_error) {
[17:29:18.481]                   sessionInformation <- function() {
[17:29:18.481]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:18.481]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:18.481]                       search = base::search(), system = base::Sys.info())
[17:29:18.481]                   }
[17:29:18.481]                   ...future.conditions[[length(...future.conditions) + 
[17:29:18.481]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:18.481]                     cond$call), session = sessionInformation(), 
[17:29:18.481]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:18.481]                   signalCondition(cond)
[17:29:18.481]                 }
[17:29:18.481]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:18.481]                 "immediateCondition"))) {
[17:29:18.481]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:18.481]                   ...future.conditions[[length(...future.conditions) + 
[17:29:18.481]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:18.481]                   if (TRUE && !signal) {
[17:29:18.481]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:18.481]                     {
[17:29:18.481]                       inherits <- base::inherits
[17:29:18.481]                       invokeRestart <- base::invokeRestart
[17:29:18.481]                       is.null <- base::is.null
[17:29:18.481]                       muffled <- FALSE
[17:29:18.481]                       if (inherits(cond, "message")) {
[17:29:18.481]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:18.481]                         if (muffled) 
[17:29:18.481]                           invokeRestart("muffleMessage")
[17:29:18.481]                       }
[17:29:18.481]                       else if (inherits(cond, "warning")) {
[17:29:18.481]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:18.481]                         if (muffled) 
[17:29:18.481]                           invokeRestart("muffleWarning")
[17:29:18.481]                       }
[17:29:18.481]                       else if (inherits(cond, "condition")) {
[17:29:18.481]                         if (!is.null(pattern)) {
[17:29:18.481]                           computeRestarts <- base::computeRestarts
[17:29:18.481]                           grepl <- base::grepl
[17:29:18.481]                           restarts <- computeRestarts(cond)
[17:29:18.481]                           for (restart in restarts) {
[17:29:18.481]                             name <- restart$name
[17:29:18.481]                             if (is.null(name)) 
[17:29:18.481]                               next
[17:29:18.481]                             if (!grepl(pattern, name)) 
[17:29:18.481]                               next
[17:29:18.481]                             invokeRestart(restart)
[17:29:18.481]                             muffled <- TRUE
[17:29:18.481]                             break
[17:29:18.481]                           }
[17:29:18.481]                         }
[17:29:18.481]                       }
[17:29:18.481]                       invisible(muffled)
[17:29:18.481]                     }
[17:29:18.481]                     muffleCondition(cond, pattern = "^muffle")
[17:29:18.481]                   }
[17:29:18.481]                 }
[17:29:18.481]                 else {
[17:29:18.481]                   if (TRUE) {
[17:29:18.481]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:18.481]                     {
[17:29:18.481]                       inherits <- base::inherits
[17:29:18.481]                       invokeRestart <- base::invokeRestart
[17:29:18.481]                       is.null <- base::is.null
[17:29:18.481]                       muffled <- FALSE
[17:29:18.481]                       if (inherits(cond, "message")) {
[17:29:18.481]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:18.481]                         if (muffled) 
[17:29:18.481]                           invokeRestart("muffleMessage")
[17:29:18.481]                       }
[17:29:18.481]                       else if (inherits(cond, "warning")) {
[17:29:18.481]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:18.481]                         if (muffled) 
[17:29:18.481]                           invokeRestart("muffleWarning")
[17:29:18.481]                       }
[17:29:18.481]                       else if (inherits(cond, "condition")) {
[17:29:18.481]                         if (!is.null(pattern)) {
[17:29:18.481]                           computeRestarts <- base::computeRestarts
[17:29:18.481]                           grepl <- base::grepl
[17:29:18.481]                           restarts <- computeRestarts(cond)
[17:29:18.481]                           for (restart in restarts) {
[17:29:18.481]                             name <- restart$name
[17:29:18.481]                             if (is.null(name)) 
[17:29:18.481]                               next
[17:29:18.481]                             if (!grepl(pattern, name)) 
[17:29:18.481]                               next
[17:29:18.481]                             invokeRestart(restart)
[17:29:18.481]                             muffled <- TRUE
[17:29:18.481]                             break
[17:29:18.481]                           }
[17:29:18.481]                         }
[17:29:18.481]                       }
[17:29:18.481]                       invisible(muffled)
[17:29:18.481]                     }
[17:29:18.481]                     muffleCondition(cond, pattern = "^muffle")
[17:29:18.481]                   }
[17:29:18.481]                 }
[17:29:18.481]             }
[17:29:18.481]         }))
[17:29:18.481]     }, error = function(ex) {
[17:29:18.481]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:18.481]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:18.481]                 ...future.rng), started = ...future.startTime, 
[17:29:18.481]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:18.481]             version = "1.8"), class = "FutureResult")
[17:29:18.481]     }, finally = {
[17:29:18.481]         if (!identical(...future.workdir, getwd())) 
[17:29:18.481]             setwd(...future.workdir)
[17:29:18.481]         {
[17:29:18.481]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:18.481]                 ...future.oldOptions$nwarnings <- NULL
[17:29:18.481]             }
[17:29:18.481]             base::options(...future.oldOptions)
[17:29:18.481]             if (.Platform$OS.type == "windows") {
[17:29:18.481]                 old_names <- names(...future.oldEnvVars)
[17:29:18.481]                 envs <- base::Sys.getenv()
[17:29:18.481]                 names <- names(envs)
[17:29:18.481]                 common <- intersect(names, old_names)
[17:29:18.481]                 added <- setdiff(names, old_names)
[17:29:18.481]                 removed <- setdiff(old_names, names)
[17:29:18.481]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:18.481]                   envs[common]]
[17:29:18.481]                 NAMES <- toupper(changed)
[17:29:18.481]                 args <- list()
[17:29:18.481]                 for (kk in seq_along(NAMES)) {
[17:29:18.481]                   name <- changed[[kk]]
[17:29:18.481]                   NAME <- NAMES[[kk]]
[17:29:18.481]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:18.481]                     next
[17:29:18.481]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:18.481]                 }
[17:29:18.481]                 NAMES <- toupper(added)
[17:29:18.481]                 for (kk in seq_along(NAMES)) {
[17:29:18.481]                   name <- added[[kk]]
[17:29:18.481]                   NAME <- NAMES[[kk]]
[17:29:18.481]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:18.481]                     next
[17:29:18.481]                   args[[name]] <- ""
[17:29:18.481]                 }
[17:29:18.481]                 NAMES <- toupper(removed)
[17:29:18.481]                 for (kk in seq_along(NAMES)) {
[17:29:18.481]                   name <- removed[[kk]]
[17:29:18.481]                   NAME <- NAMES[[kk]]
[17:29:18.481]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:18.481]                     next
[17:29:18.481]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:18.481]                 }
[17:29:18.481]                 if (length(args) > 0) 
[17:29:18.481]                   base::do.call(base::Sys.setenv, args = args)
[17:29:18.481]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:18.481]             }
[17:29:18.481]             else {
[17:29:18.481]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:18.481]             }
[17:29:18.481]             {
[17:29:18.481]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:18.481]                   0L) {
[17:29:18.481]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:18.481]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:18.481]                   base::options(opts)
[17:29:18.481]                 }
[17:29:18.481]                 {
[17:29:18.481]                   {
[17:29:18.481]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:18.481]                     NULL
[17:29:18.481]                   }
[17:29:18.481]                   options(future.plan = NULL)
[17:29:18.481]                   if (is.na(NA_character_)) 
[17:29:18.481]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:18.481]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:18.481]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:18.481]                     .init = FALSE)
[17:29:18.481]                 }
[17:29:18.481]             }
[17:29:18.481]         }
[17:29:18.481]     })
[17:29:18.481]     if (TRUE) {
[17:29:18.481]         base::sink(type = "output", split = FALSE)
[17:29:18.481]         if (TRUE) {
[17:29:18.481]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:18.481]         }
[17:29:18.481]         else {
[17:29:18.481]             ...future.result["stdout"] <- base::list(NULL)
[17:29:18.481]         }
[17:29:18.481]         base::close(...future.stdout)
[17:29:18.481]         ...future.stdout <- NULL
[17:29:18.481]     }
[17:29:18.481]     ...future.result$conditions <- ...future.conditions
[17:29:18.481]     ...future.result$finished <- base::Sys.time()
[17:29:18.481]     ...future.result
[17:29:18.481] }
[17:29:18.487] Poll #1 (0): usedNodes() = 2, workers = 2
[17:29:18.522] receiveMessageFromWorker() for ClusterFuture ...
[17:29:18.523] - Validating connection of MultisessionFuture
[17:29:18.523] - received message: FutureResult
[17:29:18.524] - Received FutureResult
[17:29:18.524] - Erased future from FutureRegistry
[17:29:18.525] result() for ClusterFuture ...
[17:29:18.525] - result already collected: FutureResult
[17:29:18.525] result() for ClusterFuture ... done
[17:29:18.525] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:18.526] result() for ClusterFuture ...
[17:29:18.526] - result already collected: FutureResult
[17:29:18.526] result() for ClusterFuture ... done
[17:29:18.527] result() for ClusterFuture ...
[17:29:18.527] - result already collected: FutureResult
[17:29:18.527] result() for ClusterFuture ... done
[17:29:18.530] MultisessionFuture started
[17:29:18.530] - Launch lazy future ... done
[17:29:18.530] run() for 'MultisessionFuture' ... done
[17:29:18.531] getGlobalsAndPackages() ...
[17:29:18.531] Searching for globals...
[17:29:18.532] - globals found: [2] 'list', 'stop'
[17:29:18.533] Searching for globals ... DONE
[17:29:18.533] Resolving globals: FALSE
[17:29:18.534] 
[17:29:18.534] 
[17:29:18.534] getGlobalsAndPackages() ... DONE
- result = TRUE, recursive = -1 ... DONE
- result = TRUE, recursive = 0 ...
[17:29:18.535] getGlobalsAndPackages() ...
[17:29:18.535] Searching for globals...
[17:29:18.538] - globals found: [3] '{', 'Sys.sleep', 'list'
[17:29:18.538] Searching for globals ... DONE
[17:29:18.538] Resolving globals: FALSE
[17:29:18.539] 
[17:29:18.539] 
[17:29:18.540] getGlobalsAndPackages() ... DONE
[17:29:18.540] run() for 'Future' ...
[17:29:18.540] - state: 'created'
[17:29:18.541] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:18.561] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:18.561] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:18.562]   - Field: 'node'
[17:29:18.562]   - Field: 'label'
[17:29:18.562]   - Field: 'local'
[17:29:18.562]   - Field: 'owner'
[17:29:18.563]   - Field: 'envir'
[17:29:18.563]   - Field: 'workers'
[17:29:18.563]   - Field: 'packages'
[17:29:18.563]   - Field: 'gc'
[17:29:18.564]   - Field: 'conditions'
[17:29:18.564]   - Field: 'persistent'
[17:29:18.564]   - Field: 'expr'
[17:29:18.564]   - Field: 'uuid'
[17:29:18.565]   - Field: 'seed'
[17:29:18.565]   - Field: 'version'
[17:29:18.565]   - Field: 'result'
[17:29:18.565]   - Field: 'asynchronous'
[17:29:18.566]   - Field: 'calls'
[17:29:18.566]   - Field: 'globals'
[17:29:18.566]   - Field: 'stdout'
[17:29:18.567]   - Field: 'earlySignal'
[17:29:18.567]   - Field: 'lazy'
[17:29:18.567]   - Field: 'state'
[17:29:18.567] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:18.568] - Launch lazy future ...
[17:29:18.568] Packages needed by the future expression (n = 0): <none>
[17:29:18.568] Packages needed by future strategies (n = 0): <none>
[17:29:18.569] {
[17:29:18.569]     {
[17:29:18.569]         {
[17:29:18.569]             ...future.startTime <- base::Sys.time()
[17:29:18.569]             {
[17:29:18.569]                 {
[17:29:18.569]                   {
[17:29:18.569]                     {
[17:29:18.569]                       base::local({
[17:29:18.569]                         has_future <- base::requireNamespace("future", 
[17:29:18.569]                           quietly = TRUE)
[17:29:18.569]                         if (has_future) {
[17:29:18.569]                           ns <- base::getNamespace("future")
[17:29:18.569]                           version <- ns[[".package"]][["version"]]
[17:29:18.569]                           if (is.null(version)) 
[17:29:18.569]                             version <- utils::packageVersion("future")
[17:29:18.569]                         }
[17:29:18.569]                         else {
[17:29:18.569]                           version <- NULL
[17:29:18.569]                         }
[17:29:18.569]                         if (!has_future || version < "1.8.0") {
[17:29:18.569]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:18.569]                             "", base::R.version$version.string), 
[17:29:18.569]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:18.569]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:18.569]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:18.569]                               "release", "version")], collapse = " "), 
[17:29:18.569]                             hostname = base::Sys.info()[["nodename"]])
[17:29:18.569]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:18.569]                             info)
[17:29:18.569]                           info <- base::paste(info, collapse = "; ")
[17:29:18.569]                           if (!has_future) {
[17:29:18.569]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:18.569]                               info)
[17:29:18.569]                           }
[17:29:18.569]                           else {
[17:29:18.569]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:18.569]                               info, version)
[17:29:18.569]                           }
[17:29:18.569]                           base::stop(msg)
[17:29:18.569]                         }
[17:29:18.569]                       })
[17:29:18.569]                     }
[17:29:18.569]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:18.569]                     base::options(mc.cores = 1L)
[17:29:18.569]                   }
[17:29:18.569]                   ...future.strategy.old <- future::plan("list")
[17:29:18.569]                   options(future.plan = NULL)
[17:29:18.569]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:18.569]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:18.569]                 }
[17:29:18.569]                 ...future.workdir <- getwd()
[17:29:18.569]             }
[17:29:18.569]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:18.569]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:18.569]         }
[17:29:18.569]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:18.569]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:18.569]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:18.569]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:18.569]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:18.569]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:18.569]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:18.569]             base::names(...future.oldOptions))
[17:29:18.569]     }
[17:29:18.569]     if (FALSE) {
[17:29:18.569]     }
[17:29:18.569]     else {
[17:29:18.569]         if (TRUE) {
[17:29:18.569]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:18.569]                 open = "w")
[17:29:18.569]         }
[17:29:18.569]         else {
[17:29:18.569]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:18.569]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:18.569]         }
[17:29:18.569]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:18.569]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:18.569]             base::sink(type = "output", split = FALSE)
[17:29:18.569]             base::close(...future.stdout)
[17:29:18.569]         }, add = TRUE)
[17:29:18.569]     }
[17:29:18.569]     ...future.frame <- base::sys.nframe()
[17:29:18.569]     ...future.conditions <- base::list()
[17:29:18.569]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:18.569]     if (FALSE) {
[17:29:18.569]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:18.569]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:18.569]     }
[17:29:18.569]     ...future.result <- base::tryCatch({
[17:29:18.569]         base::withCallingHandlers({
[17:29:18.569]             ...future.value <- base::withVisible(base::local({
[17:29:18.569]                 ...future.makeSendCondition <- base::local({
[17:29:18.569]                   sendCondition <- NULL
[17:29:18.569]                   function(frame = 1L) {
[17:29:18.569]                     if (is.function(sendCondition)) 
[17:29:18.569]                       return(sendCondition)
[17:29:18.569]                     ns <- getNamespace("parallel")
[17:29:18.569]                     if (exists("sendData", mode = "function", 
[17:29:18.569]                       envir = ns)) {
[17:29:18.569]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:18.569]                         envir = ns)
[17:29:18.569]                       envir <- sys.frame(frame)
[17:29:18.569]                       master <- NULL
[17:29:18.569]                       while (!identical(envir, .GlobalEnv) && 
[17:29:18.569]                         !identical(envir, emptyenv())) {
[17:29:18.569]                         if (exists("master", mode = "list", envir = envir, 
[17:29:18.569]                           inherits = FALSE)) {
[17:29:18.569]                           master <- get("master", mode = "list", 
[17:29:18.569]                             envir = envir, inherits = FALSE)
[17:29:18.569]                           if (inherits(master, c("SOCKnode", 
[17:29:18.569]                             "SOCK0node"))) {
[17:29:18.569]                             sendCondition <<- function(cond) {
[17:29:18.569]                               data <- list(type = "VALUE", value = cond, 
[17:29:18.569]                                 success = TRUE)
[17:29:18.569]                               parallel_sendData(master, data)
[17:29:18.569]                             }
[17:29:18.569]                             return(sendCondition)
[17:29:18.569]                           }
[17:29:18.569]                         }
[17:29:18.569]                         frame <- frame + 1L
[17:29:18.569]                         envir <- sys.frame(frame)
[17:29:18.569]                       }
[17:29:18.569]                     }
[17:29:18.569]                     sendCondition <<- function(cond) NULL
[17:29:18.569]                   }
[17:29:18.569]                 })
[17:29:18.569]                 withCallingHandlers({
[17:29:18.569]                   {
[17:29:18.569]                     Sys.sleep(0.5)
[17:29:18.569]                     list(a = 1, b = 42L)
[17:29:18.569]                   }
[17:29:18.569]                 }, immediateCondition = function(cond) {
[17:29:18.569]                   sendCondition <- ...future.makeSendCondition()
[17:29:18.569]                   sendCondition(cond)
[17:29:18.569]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:18.569]                   {
[17:29:18.569]                     inherits <- base::inherits
[17:29:18.569]                     invokeRestart <- base::invokeRestart
[17:29:18.569]                     is.null <- base::is.null
[17:29:18.569]                     muffled <- FALSE
[17:29:18.569]                     if (inherits(cond, "message")) {
[17:29:18.569]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:18.569]                       if (muffled) 
[17:29:18.569]                         invokeRestart("muffleMessage")
[17:29:18.569]                     }
[17:29:18.569]                     else if (inherits(cond, "warning")) {
[17:29:18.569]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:18.569]                       if (muffled) 
[17:29:18.569]                         invokeRestart("muffleWarning")
[17:29:18.569]                     }
[17:29:18.569]                     else if (inherits(cond, "condition")) {
[17:29:18.569]                       if (!is.null(pattern)) {
[17:29:18.569]                         computeRestarts <- base::computeRestarts
[17:29:18.569]                         grepl <- base::grepl
[17:29:18.569]                         restarts <- computeRestarts(cond)
[17:29:18.569]                         for (restart in restarts) {
[17:29:18.569]                           name <- restart$name
[17:29:18.569]                           if (is.null(name)) 
[17:29:18.569]                             next
[17:29:18.569]                           if (!grepl(pattern, name)) 
[17:29:18.569]                             next
[17:29:18.569]                           invokeRestart(restart)
[17:29:18.569]                           muffled <- TRUE
[17:29:18.569]                           break
[17:29:18.569]                         }
[17:29:18.569]                       }
[17:29:18.569]                     }
[17:29:18.569]                     invisible(muffled)
[17:29:18.569]                   }
[17:29:18.569]                   muffleCondition(cond)
[17:29:18.569]                 })
[17:29:18.569]             }))
[17:29:18.569]             future::FutureResult(value = ...future.value$value, 
[17:29:18.569]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:18.569]                   ...future.rng), globalenv = if (FALSE) 
[17:29:18.569]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:18.569]                     ...future.globalenv.names))
[17:29:18.569]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:18.569]         }, condition = base::local({
[17:29:18.569]             c <- base::c
[17:29:18.569]             inherits <- base::inherits
[17:29:18.569]             invokeRestart <- base::invokeRestart
[17:29:18.569]             length <- base::length
[17:29:18.569]             list <- base::list
[17:29:18.569]             seq.int <- base::seq.int
[17:29:18.569]             signalCondition <- base::signalCondition
[17:29:18.569]             sys.calls <- base::sys.calls
[17:29:18.569]             `[[` <- base::`[[`
[17:29:18.569]             `+` <- base::`+`
[17:29:18.569]             `<<-` <- base::`<<-`
[17:29:18.569]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:18.569]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:18.569]                   3L)]
[17:29:18.569]             }
[17:29:18.569]             function(cond) {
[17:29:18.569]                 is_error <- inherits(cond, "error")
[17:29:18.569]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:18.569]                   NULL)
[17:29:18.569]                 if (is_error) {
[17:29:18.569]                   sessionInformation <- function() {
[17:29:18.569]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:18.569]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:18.569]                       search = base::search(), system = base::Sys.info())
[17:29:18.569]                   }
[17:29:18.569]                   ...future.conditions[[length(...future.conditions) + 
[17:29:18.569]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:18.569]                     cond$call), session = sessionInformation(), 
[17:29:18.569]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:18.569]                   signalCondition(cond)
[17:29:18.569]                 }
[17:29:18.569]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:18.569]                 "immediateCondition"))) {
[17:29:18.569]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:18.569]                   ...future.conditions[[length(...future.conditions) + 
[17:29:18.569]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:18.569]                   if (TRUE && !signal) {
[17:29:18.569]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:18.569]                     {
[17:29:18.569]                       inherits <- base::inherits
[17:29:18.569]                       invokeRestart <- base::invokeRestart
[17:29:18.569]                       is.null <- base::is.null
[17:29:18.569]                       muffled <- FALSE
[17:29:18.569]                       if (inherits(cond, "message")) {
[17:29:18.569]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:18.569]                         if (muffled) 
[17:29:18.569]                           invokeRestart("muffleMessage")
[17:29:18.569]                       }
[17:29:18.569]                       else if (inherits(cond, "warning")) {
[17:29:18.569]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:18.569]                         if (muffled) 
[17:29:18.569]                           invokeRestart("muffleWarning")
[17:29:18.569]                       }
[17:29:18.569]                       else if (inherits(cond, "condition")) {
[17:29:18.569]                         if (!is.null(pattern)) {
[17:29:18.569]                           computeRestarts <- base::computeRestarts
[17:29:18.569]                           grepl <- base::grepl
[17:29:18.569]                           restarts <- computeRestarts(cond)
[17:29:18.569]                           for (restart in restarts) {
[17:29:18.569]                             name <- restart$name
[17:29:18.569]                             if (is.null(name)) 
[17:29:18.569]                               next
[17:29:18.569]                             if (!grepl(pattern, name)) 
[17:29:18.569]                               next
[17:29:18.569]                             invokeRestart(restart)
[17:29:18.569]                             muffled <- TRUE
[17:29:18.569]                             break
[17:29:18.569]                           }
[17:29:18.569]                         }
[17:29:18.569]                       }
[17:29:18.569]                       invisible(muffled)
[17:29:18.569]                     }
[17:29:18.569]                     muffleCondition(cond, pattern = "^muffle")
[17:29:18.569]                   }
[17:29:18.569]                 }
[17:29:18.569]                 else {
[17:29:18.569]                   if (TRUE) {
[17:29:18.569]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:18.569]                     {
[17:29:18.569]                       inherits <- base::inherits
[17:29:18.569]                       invokeRestart <- base::invokeRestart
[17:29:18.569]                       is.null <- base::is.null
[17:29:18.569]                       muffled <- FALSE
[17:29:18.569]                       if (inherits(cond, "message")) {
[17:29:18.569]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:18.569]                         if (muffled) 
[17:29:18.569]                           invokeRestart("muffleMessage")
[17:29:18.569]                       }
[17:29:18.569]                       else if (inherits(cond, "warning")) {
[17:29:18.569]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:18.569]                         if (muffled) 
[17:29:18.569]                           invokeRestart("muffleWarning")
[17:29:18.569]                       }
[17:29:18.569]                       else if (inherits(cond, "condition")) {
[17:29:18.569]                         if (!is.null(pattern)) {
[17:29:18.569]                           computeRestarts <- base::computeRestarts
[17:29:18.569]                           grepl <- base::grepl
[17:29:18.569]                           restarts <- computeRestarts(cond)
[17:29:18.569]                           for (restart in restarts) {
[17:29:18.569]                             name <- restart$name
[17:29:18.569]                             if (is.null(name)) 
[17:29:18.569]                               next
[17:29:18.569]                             if (!grepl(pattern, name)) 
[17:29:18.569]                               next
[17:29:18.569]                             invokeRestart(restart)
[17:29:18.569]                             muffled <- TRUE
[17:29:18.569]                             break
[17:29:18.569]                           }
[17:29:18.569]                         }
[17:29:18.569]                       }
[17:29:18.569]                       invisible(muffled)
[17:29:18.569]                     }
[17:29:18.569]                     muffleCondition(cond, pattern = "^muffle")
[17:29:18.569]                   }
[17:29:18.569]                 }
[17:29:18.569]             }
[17:29:18.569]         }))
[17:29:18.569]     }, error = function(ex) {
[17:29:18.569]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:18.569]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:18.569]                 ...future.rng), started = ...future.startTime, 
[17:29:18.569]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:18.569]             version = "1.8"), class = "FutureResult")
[17:29:18.569]     }, finally = {
[17:29:18.569]         if (!identical(...future.workdir, getwd())) 
[17:29:18.569]             setwd(...future.workdir)
[17:29:18.569]         {
[17:29:18.569]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:18.569]                 ...future.oldOptions$nwarnings <- NULL
[17:29:18.569]             }
[17:29:18.569]             base::options(...future.oldOptions)
[17:29:18.569]             if (.Platform$OS.type == "windows") {
[17:29:18.569]                 old_names <- names(...future.oldEnvVars)
[17:29:18.569]                 envs <- base::Sys.getenv()
[17:29:18.569]                 names <- names(envs)
[17:29:18.569]                 common <- intersect(names, old_names)
[17:29:18.569]                 added <- setdiff(names, old_names)
[17:29:18.569]                 removed <- setdiff(old_names, names)
[17:29:18.569]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:18.569]                   envs[common]]
[17:29:18.569]                 NAMES <- toupper(changed)
[17:29:18.569]                 args <- list()
[17:29:18.569]                 for (kk in seq_along(NAMES)) {
[17:29:18.569]                   name <- changed[[kk]]
[17:29:18.569]                   NAME <- NAMES[[kk]]
[17:29:18.569]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:18.569]                     next
[17:29:18.569]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:18.569]                 }
[17:29:18.569]                 NAMES <- toupper(added)
[17:29:18.569]                 for (kk in seq_along(NAMES)) {
[17:29:18.569]                   name <- added[[kk]]
[17:29:18.569]                   NAME <- NAMES[[kk]]
[17:29:18.569]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:18.569]                     next
[17:29:18.569]                   args[[name]] <- ""
[17:29:18.569]                 }
[17:29:18.569]                 NAMES <- toupper(removed)
[17:29:18.569]                 for (kk in seq_along(NAMES)) {
[17:29:18.569]                   name <- removed[[kk]]
[17:29:18.569]                   NAME <- NAMES[[kk]]
[17:29:18.569]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:18.569]                     next
[17:29:18.569]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:18.569]                 }
[17:29:18.569]                 if (length(args) > 0) 
[17:29:18.569]                   base::do.call(base::Sys.setenv, args = args)
[17:29:18.569]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:18.569]             }
[17:29:18.569]             else {
[17:29:18.569]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:18.569]             }
[17:29:18.569]             {
[17:29:18.569]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:18.569]                   0L) {
[17:29:18.569]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:18.569]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:18.569]                   base::options(opts)
[17:29:18.569]                 }
[17:29:18.569]                 {
[17:29:18.569]                   {
[17:29:18.569]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:18.569]                     NULL
[17:29:18.569]                   }
[17:29:18.569]                   options(future.plan = NULL)
[17:29:18.569]                   if (is.na(NA_character_)) 
[17:29:18.569]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:18.569]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:18.569]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:18.569]                     .init = FALSE)
[17:29:18.569]                 }
[17:29:18.569]             }
[17:29:18.569]         }
[17:29:18.569]     })
[17:29:18.569]     if (TRUE) {
[17:29:18.569]         base::sink(type = "output", split = FALSE)
[17:29:18.569]         if (TRUE) {
[17:29:18.569]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:18.569]         }
[17:29:18.569]         else {
[17:29:18.569]             ...future.result["stdout"] <- base::list(NULL)
[17:29:18.569]         }
[17:29:18.569]         base::close(...future.stdout)
[17:29:18.569]         ...future.stdout <- NULL
[17:29:18.569]     }
[17:29:18.569]     ...future.result$conditions <- ...future.conditions
[17:29:18.569]     ...future.result$finished <- base::Sys.time()
[17:29:18.569]     ...future.result
[17:29:18.569] }
[17:29:18.577] Poll #1 (0): usedNodes() = 2, workers = 2
[17:29:18.800] receiveMessageFromWorker() for ClusterFuture ...
[17:29:18.801] - Validating connection of MultisessionFuture
[17:29:18.802] - received message: FutureResult
[17:29:18.803] - Received FutureResult
[17:29:18.803] - Erased future from FutureRegistry
[17:29:18.803] result() for ClusterFuture ...
[17:29:18.804] - result already collected: FutureResult
[17:29:18.804] result() for ClusterFuture ... done
[17:29:18.804] signalConditions() ...
[17:29:18.805]  - include = 'immediateCondition'
[17:29:18.805]  - exclude = 
[17:29:18.805]  - resignal = FALSE
[17:29:18.806]  - Number of conditions: 1
[17:29:18.806] signalConditions() ... done
[17:29:18.807] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:18.807] result() for ClusterFuture ...
[17:29:18.807] - result already collected: FutureResult
[17:29:18.808] result() for ClusterFuture ... done
[17:29:18.808] result() for ClusterFuture ...
[17:29:18.808] - result already collected: FutureResult
[17:29:18.809] result() for ClusterFuture ... done
[17:29:18.809] signalConditions() ...
[17:29:18.809]  - include = 'immediateCondition'
[17:29:18.810]  - exclude = 
[17:29:18.810]  - resignal = FALSE
[17:29:18.810]  - Number of conditions: 1
[17:29:18.811] signalConditions() ... done
[17:29:18.813] MultisessionFuture started
[17:29:18.814] - Launch lazy future ... done
[17:29:18.814] run() for 'MultisessionFuture' ... done
[17:29:19.336] receiveMessageFromWorker() for ClusterFuture ...
[17:29:19.336] - Validating connection of MultisessionFuture
[17:29:19.337] - received message: FutureResult
[17:29:19.337] - Received FutureResult
[17:29:19.337] - Erased future from FutureRegistry
[17:29:19.338] result() for ClusterFuture ...
[17:29:19.338] - result already collected: FutureResult
[17:29:19.338] result() for ClusterFuture ... done
[17:29:19.339] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:19.339] A MultisessionFuture was resolved
[17:29:19.339] getGlobalsAndPackages() ...
[17:29:19.340] Searching for globals...
[17:29:19.342] - globals found: [3] '{', 'Sys.sleep', 'list'
[17:29:19.343] Searching for globals ... DONE
[17:29:19.343] Resolving globals: FALSE
[17:29:19.344] 
[17:29:19.344] 
[17:29:19.344] getGlobalsAndPackages() ... DONE
[17:29:19.345] run() for 'Future' ...
[17:29:19.345] - state: 'created'
[17:29:19.346] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:19.365] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:19.366] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:19.366]   - Field: 'node'
[17:29:19.366]   - Field: 'label'
[17:29:19.367]   - Field: 'local'
[17:29:19.367]   - Field: 'owner'
[17:29:19.367]   - Field: 'envir'
[17:29:19.368]   - Field: 'workers'
[17:29:19.368]   - Field: 'packages'
[17:29:19.368]   - Field: 'gc'
[17:29:19.369]   - Field: 'conditions'
[17:29:19.369]   - Field: 'persistent'
[17:29:19.369]   - Field: 'expr'
[17:29:19.370]   - Field: 'uuid'
[17:29:19.370]   - Field: 'seed'
[17:29:19.370]   - Field: 'version'
[17:29:19.371]   - Field: 'result'
[17:29:19.371]   - Field: 'asynchronous'
[17:29:19.371]   - Field: 'calls'
[17:29:19.372]   - Field: 'globals'
[17:29:19.372]   - Field: 'stdout'
[17:29:19.372]   - Field: 'earlySignal'
[17:29:19.372]   - Field: 'lazy'
[17:29:19.373]   - Field: 'state'
[17:29:19.373] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:19.373] - Launch lazy future ...
[17:29:19.374] Packages needed by the future expression (n = 0): <none>
[17:29:19.374] Packages needed by future strategies (n = 0): <none>
[17:29:19.375] {
[17:29:19.375]     {
[17:29:19.375]         {
[17:29:19.375]             ...future.startTime <- base::Sys.time()
[17:29:19.375]             {
[17:29:19.375]                 {
[17:29:19.375]                   {
[17:29:19.375]                     {
[17:29:19.375]                       base::local({
[17:29:19.375]                         has_future <- base::requireNamespace("future", 
[17:29:19.375]                           quietly = TRUE)
[17:29:19.375]                         if (has_future) {
[17:29:19.375]                           ns <- base::getNamespace("future")
[17:29:19.375]                           version <- ns[[".package"]][["version"]]
[17:29:19.375]                           if (is.null(version)) 
[17:29:19.375]                             version <- utils::packageVersion("future")
[17:29:19.375]                         }
[17:29:19.375]                         else {
[17:29:19.375]                           version <- NULL
[17:29:19.375]                         }
[17:29:19.375]                         if (!has_future || version < "1.8.0") {
[17:29:19.375]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:19.375]                             "", base::R.version$version.string), 
[17:29:19.375]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:19.375]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:19.375]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:19.375]                               "release", "version")], collapse = " "), 
[17:29:19.375]                             hostname = base::Sys.info()[["nodename"]])
[17:29:19.375]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:19.375]                             info)
[17:29:19.375]                           info <- base::paste(info, collapse = "; ")
[17:29:19.375]                           if (!has_future) {
[17:29:19.375]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:19.375]                               info)
[17:29:19.375]                           }
[17:29:19.375]                           else {
[17:29:19.375]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:19.375]                               info, version)
[17:29:19.375]                           }
[17:29:19.375]                           base::stop(msg)
[17:29:19.375]                         }
[17:29:19.375]                       })
[17:29:19.375]                     }
[17:29:19.375]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:19.375]                     base::options(mc.cores = 1L)
[17:29:19.375]                   }
[17:29:19.375]                   ...future.strategy.old <- future::plan("list")
[17:29:19.375]                   options(future.plan = NULL)
[17:29:19.375]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:19.375]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:19.375]                 }
[17:29:19.375]                 ...future.workdir <- getwd()
[17:29:19.375]             }
[17:29:19.375]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:19.375]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:19.375]         }
[17:29:19.375]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:19.375]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:19.375]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:19.375]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:19.375]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:19.375]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:19.375]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:19.375]             base::names(...future.oldOptions))
[17:29:19.375]     }
[17:29:19.375]     if (FALSE) {
[17:29:19.375]     }
[17:29:19.375]     else {
[17:29:19.375]         if (TRUE) {
[17:29:19.375]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:19.375]                 open = "w")
[17:29:19.375]         }
[17:29:19.375]         else {
[17:29:19.375]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:19.375]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:19.375]         }
[17:29:19.375]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:19.375]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:19.375]             base::sink(type = "output", split = FALSE)
[17:29:19.375]             base::close(...future.stdout)
[17:29:19.375]         }, add = TRUE)
[17:29:19.375]     }
[17:29:19.375]     ...future.frame <- base::sys.nframe()
[17:29:19.375]     ...future.conditions <- base::list()
[17:29:19.375]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:19.375]     if (FALSE) {
[17:29:19.375]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:19.375]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:19.375]     }
[17:29:19.375]     ...future.result <- base::tryCatch({
[17:29:19.375]         base::withCallingHandlers({
[17:29:19.375]             ...future.value <- base::withVisible(base::local({
[17:29:19.375]                 ...future.makeSendCondition <- base::local({
[17:29:19.375]                   sendCondition <- NULL
[17:29:19.375]                   function(frame = 1L) {
[17:29:19.375]                     if (is.function(sendCondition)) 
[17:29:19.375]                       return(sendCondition)
[17:29:19.375]                     ns <- getNamespace("parallel")
[17:29:19.375]                     if (exists("sendData", mode = "function", 
[17:29:19.375]                       envir = ns)) {
[17:29:19.375]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:19.375]                         envir = ns)
[17:29:19.375]                       envir <- sys.frame(frame)
[17:29:19.375]                       master <- NULL
[17:29:19.375]                       while (!identical(envir, .GlobalEnv) && 
[17:29:19.375]                         !identical(envir, emptyenv())) {
[17:29:19.375]                         if (exists("master", mode = "list", envir = envir, 
[17:29:19.375]                           inherits = FALSE)) {
[17:29:19.375]                           master <- get("master", mode = "list", 
[17:29:19.375]                             envir = envir, inherits = FALSE)
[17:29:19.375]                           if (inherits(master, c("SOCKnode", 
[17:29:19.375]                             "SOCK0node"))) {
[17:29:19.375]                             sendCondition <<- function(cond) {
[17:29:19.375]                               data <- list(type = "VALUE", value = cond, 
[17:29:19.375]                                 success = TRUE)
[17:29:19.375]                               parallel_sendData(master, data)
[17:29:19.375]                             }
[17:29:19.375]                             return(sendCondition)
[17:29:19.375]                           }
[17:29:19.375]                         }
[17:29:19.375]                         frame <- frame + 1L
[17:29:19.375]                         envir <- sys.frame(frame)
[17:29:19.375]                       }
[17:29:19.375]                     }
[17:29:19.375]                     sendCondition <<- function(cond) NULL
[17:29:19.375]                   }
[17:29:19.375]                 })
[17:29:19.375]                 withCallingHandlers({
[17:29:19.375]                   {
[17:29:19.375]                     Sys.sleep(0.5)
[17:29:19.375]                     list(a = 1, b = 42L)
[17:29:19.375]                   }
[17:29:19.375]                 }, immediateCondition = function(cond) {
[17:29:19.375]                   sendCondition <- ...future.makeSendCondition()
[17:29:19.375]                   sendCondition(cond)
[17:29:19.375]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:19.375]                   {
[17:29:19.375]                     inherits <- base::inherits
[17:29:19.375]                     invokeRestart <- base::invokeRestart
[17:29:19.375]                     is.null <- base::is.null
[17:29:19.375]                     muffled <- FALSE
[17:29:19.375]                     if (inherits(cond, "message")) {
[17:29:19.375]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:19.375]                       if (muffled) 
[17:29:19.375]                         invokeRestart("muffleMessage")
[17:29:19.375]                     }
[17:29:19.375]                     else if (inherits(cond, "warning")) {
[17:29:19.375]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:19.375]                       if (muffled) 
[17:29:19.375]                         invokeRestart("muffleWarning")
[17:29:19.375]                     }
[17:29:19.375]                     else if (inherits(cond, "condition")) {
[17:29:19.375]                       if (!is.null(pattern)) {
[17:29:19.375]                         computeRestarts <- base::computeRestarts
[17:29:19.375]                         grepl <- base::grepl
[17:29:19.375]                         restarts <- computeRestarts(cond)
[17:29:19.375]                         for (restart in restarts) {
[17:29:19.375]                           name <- restart$name
[17:29:19.375]                           if (is.null(name)) 
[17:29:19.375]                             next
[17:29:19.375]                           if (!grepl(pattern, name)) 
[17:29:19.375]                             next
[17:29:19.375]                           invokeRestart(restart)
[17:29:19.375]                           muffled <- TRUE
[17:29:19.375]                           break
[17:29:19.375]                         }
[17:29:19.375]                       }
[17:29:19.375]                     }
[17:29:19.375]                     invisible(muffled)
[17:29:19.375]                   }
[17:29:19.375]                   muffleCondition(cond)
[17:29:19.375]                 })
[17:29:19.375]             }))
[17:29:19.375]             future::FutureResult(value = ...future.value$value, 
[17:29:19.375]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:19.375]                   ...future.rng), globalenv = if (FALSE) 
[17:29:19.375]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:19.375]                     ...future.globalenv.names))
[17:29:19.375]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:19.375]         }, condition = base::local({
[17:29:19.375]             c <- base::c
[17:29:19.375]             inherits <- base::inherits
[17:29:19.375]             invokeRestart <- base::invokeRestart
[17:29:19.375]             length <- base::length
[17:29:19.375]             list <- base::list
[17:29:19.375]             seq.int <- base::seq.int
[17:29:19.375]             signalCondition <- base::signalCondition
[17:29:19.375]             sys.calls <- base::sys.calls
[17:29:19.375]             `[[` <- base::`[[`
[17:29:19.375]             `+` <- base::`+`
[17:29:19.375]             `<<-` <- base::`<<-`
[17:29:19.375]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:19.375]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:19.375]                   3L)]
[17:29:19.375]             }
[17:29:19.375]             function(cond) {
[17:29:19.375]                 is_error <- inherits(cond, "error")
[17:29:19.375]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:19.375]                   NULL)
[17:29:19.375]                 if (is_error) {
[17:29:19.375]                   sessionInformation <- function() {
[17:29:19.375]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:19.375]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:19.375]                       search = base::search(), system = base::Sys.info())
[17:29:19.375]                   }
[17:29:19.375]                   ...future.conditions[[length(...future.conditions) + 
[17:29:19.375]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:19.375]                     cond$call), session = sessionInformation(), 
[17:29:19.375]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:19.375]                   signalCondition(cond)
[17:29:19.375]                 }
[17:29:19.375]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:19.375]                 "immediateCondition"))) {
[17:29:19.375]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:19.375]                   ...future.conditions[[length(...future.conditions) + 
[17:29:19.375]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:19.375]                   if (TRUE && !signal) {
[17:29:19.375]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:19.375]                     {
[17:29:19.375]                       inherits <- base::inherits
[17:29:19.375]                       invokeRestart <- base::invokeRestart
[17:29:19.375]                       is.null <- base::is.null
[17:29:19.375]                       muffled <- FALSE
[17:29:19.375]                       if (inherits(cond, "message")) {
[17:29:19.375]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:19.375]                         if (muffled) 
[17:29:19.375]                           invokeRestart("muffleMessage")
[17:29:19.375]                       }
[17:29:19.375]                       else if (inherits(cond, "warning")) {
[17:29:19.375]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:19.375]                         if (muffled) 
[17:29:19.375]                           invokeRestart("muffleWarning")
[17:29:19.375]                       }
[17:29:19.375]                       else if (inherits(cond, "condition")) {
[17:29:19.375]                         if (!is.null(pattern)) {
[17:29:19.375]                           computeRestarts <- base::computeRestarts
[17:29:19.375]                           grepl <- base::grepl
[17:29:19.375]                           restarts <- computeRestarts(cond)
[17:29:19.375]                           for (restart in restarts) {
[17:29:19.375]                             name <- restart$name
[17:29:19.375]                             if (is.null(name)) 
[17:29:19.375]                               next
[17:29:19.375]                             if (!grepl(pattern, name)) 
[17:29:19.375]                               next
[17:29:19.375]                             invokeRestart(restart)
[17:29:19.375]                             muffled <- TRUE
[17:29:19.375]                             break
[17:29:19.375]                           }
[17:29:19.375]                         }
[17:29:19.375]                       }
[17:29:19.375]                       invisible(muffled)
[17:29:19.375]                     }
[17:29:19.375]                     muffleCondition(cond, pattern = "^muffle")
[17:29:19.375]                   }
[17:29:19.375]                 }
[17:29:19.375]                 else {
[17:29:19.375]                   if (TRUE) {
[17:29:19.375]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:19.375]                     {
[17:29:19.375]                       inherits <- base::inherits
[17:29:19.375]                       invokeRestart <- base::invokeRestart
[17:29:19.375]                       is.null <- base::is.null
[17:29:19.375]                       muffled <- FALSE
[17:29:19.375]                       if (inherits(cond, "message")) {
[17:29:19.375]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:19.375]                         if (muffled) 
[17:29:19.375]                           invokeRestart("muffleMessage")
[17:29:19.375]                       }
[17:29:19.375]                       else if (inherits(cond, "warning")) {
[17:29:19.375]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:19.375]                         if (muffled) 
[17:29:19.375]                           invokeRestart("muffleWarning")
[17:29:19.375]                       }
[17:29:19.375]                       else if (inherits(cond, "condition")) {
[17:29:19.375]                         if (!is.null(pattern)) {
[17:29:19.375]                           computeRestarts <- base::computeRestarts
[17:29:19.375]                           grepl <- base::grepl
[17:29:19.375]                           restarts <- computeRestarts(cond)
[17:29:19.375]                           for (restart in restarts) {
[17:29:19.375]                             name <- restart$name
[17:29:19.375]                             if (is.null(name)) 
[17:29:19.375]                               next
[17:29:19.375]                             if (!grepl(pattern, name)) 
[17:29:19.375]                               next
[17:29:19.375]                             invokeRestart(restart)
[17:29:19.375]                             muffled <- TRUE
[17:29:19.375]                             break
[17:29:19.375]                           }
[17:29:19.375]                         }
[17:29:19.375]                       }
[17:29:19.375]                       invisible(muffled)
[17:29:19.375]                     }
[17:29:19.375]                     muffleCondition(cond, pattern = "^muffle")
[17:29:19.375]                   }
[17:29:19.375]                 }
[17:29:19.375]             }
[17:29:19.375]         }))
[17:29:19.375]     }, error = function(ex) {
[17:29:19.375]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:19.375]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:19.375]                 ...future.rng), started = ...future.startTime, 
[17:29:19.375]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:19.375]             version = "1.8"), class = "FutureResult")
[17:29:19.375]     }, finally = {
[17:29:19.375]         if (!identical(...future.workdir, getwd())) 
[17:29:19.375]             setwd(...future.workdir)
[17:29:19.375]         {
[17:29:19.375]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:19.375]                 ...future.oldOptions$nwarnings <- NULL
[17:29:19.375]             }
[17:29:19.375]             base::options(...future.oldOptions)
[17:29:19.375]             if (.Platform$OS.type == "windows") {
[17:29:19.375]                 old_names <- names(...future.oldEnvVars)
[17:29:19.375]                 envs <- base::Sys.getenv()
[17:29:19.375]                 names <- names(envs)
[17:29:19.375]                 common <- intersect(names, old_names)
[17:29:19.375]                 added <- setdiff(names, old_names)
[17:29:19.375]                 removed <- setdiff(old_names, names)
[17:29:19.375]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:19.375]                   envs[common]]
[17:29:19.375]                 NAMES <- toupper(changed)
[17:29:19.375]                 args <- list()
[17:29:19.375]                 for (kk in seq_along(NAMES)) {
[17:29:19.375]                   name <- changed[[kk]]
[17:29:19.375]                   NAME <- NAMES[[kk]]
[17:29:19.375]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:19.375]                     next
[17:29:19.375]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:19.375]                 }
[17:29:19.375]                 NAMES <- toupper(added)
[17:29:19.375]                 for (kk in seq_along(NAMES)) {
[17:29:19.375]                   name <- added[[kk]]
[17:29:19.375]                   NAME <- NAMES[[kk]]
[17:29:19.375]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:19.375]                     next
[17:29:19.375]                   args[[name]] <- ""
[17:29:19.375]                 }
[17:29:19.375]                 NAMES <- toupper(removed)
[17:29:19.375]                 for (kk in seq_along(NAMES)) {
[17:29:19.375]                   name <- removed[[kk]]
[17:29:19.375]                   NAME <- NAMES[[kk]]
[17:29:19.375]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:19.375]                     next
[17:29:19.375]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:19.375]                 }
[17:29:19.375]                 if (length(args) > 0) 
[17:29:19.375]                   base::do.call(base::Sys.setenv, args = args)
[17:29:19.375]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:19.375]             }
[17:29:19.375]             else {
[17:29:19.375]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:19.375]             }
[17:29:19.375]             {
[17:29:19.375]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:19.375]                   0L) {
[17:29:19.375]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:19.375]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:19.375]                   base::options(opts)
[17:29:19.375]                 }
[17:29:19.375]                 {
[17:29:19.375]                   {
[17:29:19.375]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:19.375]                     NULL
[17:29:19.375]                   }
[17:29:19.375]                   options(future.plan = NULL)
[17:29:19.375]                   if (is.na(NA_character_)) 
[17:29:19.375]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:19.375]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:19.375]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:19.375]                     .init = FALSE)
[17:29:19.375]                 }
[17:29:19.375]             }
[17:29:19.375]         }
[17:29:19.375]     })
[17:29:19.375]     if (TRUE) {
[17:29:19.375]         base::sink(type = "output", split = FALSE)
[17:29:19.375]         if (TRUE) {
[17:29:19.375]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:19.375]         }
[17:29:19.375]         else {
[17:29:19.375]             ...future.result["stdout"] <- base::list(NULL)
[17:29:19.375]         }
[17:29:19.375]         base::close(...future.stdout)
[17:29:19.375]         ...future.stdout <- NULL
[17:29:19.375]     }
[17:29:19.375]     ...future.result$conditions <- ...future.conditions
[17:29:19.375]     ...future.result$finished <- base::Sys.time()
[17:29:19.375]     ...future.result
[17:29:19.375] }
[17:29:19.385] MultisessionFuture started
[17:29:19.386] - Launch lazy future ... done
[17:29:19.386] run() for 'MultisessionFuture' ... done
[17:29:19.918] receiveMessageFromWorker() for ClusterFuture ...
[17:29:19.919] - Validating connection of MultisessionFuture
[17:29:19.919] - received message: FutureResult
[17:29:19.920] - Received FutureResult
[17:29:19.920] - Erased future from FutureRegistry
[17:29:19.920] result() for ClusterFuture ...
[17:29:19.920] - result already collected: FutureResult
[17:29:19.921] result() for ClusterFuture ... done
[17:29:19.921] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:19.921] A MultisessionFuture was resolved
- w/ exception ...
[17:29:19.922] getGlobalsAndPackages() ...
[17:29:19.922] Searching for globals...
[17:29:19.924] - globals found: [2] 'list', 'stop'
[17:29:19.925] Searching for globals ... DONE
[17:29:19.925] Resolving globals: FALSE
[17:29:19.926] 
[17:29:19.926] 
[17:29:19.927] getGlobalsAndPackages() ... DONE
[17:29:19.927] run() for 'Future' ...
[17:29:19.927] - state: 'created'
[17:29:19.928] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:19.949] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:19.949] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:19.950]   - Field: 'node'
[17:29:19.950]   - Field: 'label'
[17:29:19.950]   - Field: 'local'
[17:29:19.951]   - Field: 'owner'
[17:29:19.951]   - Field: 'envir'
[17:29:19.951]   - Field: 'workers'
[17:29:19.952]   - Field: 'packages'
[17:29:19.952]   - Field: 'gc'
[17:29:19.952]   - Field: 'conditions'
[17:29:19.953]   - Field: 'persistent'
[17:29:19.953]   - Field: 'expr'
[17:29:19.953]   - Field: 'uuid'
[17:29:19.954]   - Field: 'seed'
[17:29:19.954]   - Field: 'version'
[17:29:19.954]   - Field: 'result'
[17:29:19.955]   - Field: 'asynchronous'
[17:29:19.955]   - Field: 'calls'
[17:29:19.955]   - Field: 'globals'
[17:29:19.956]   - Field: 'stdout'
[17:29:19.956]   - Field: 'earlySignal'
[17:29:19.956]   - Field: 'lazy'
[17:29:19.956]   - Field: 'state'
[17:29:19.957] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:19.957] - Launch lazy future ...
[17:29:19.958] Packages needed by the future expression (n = 0): <none>
[17:29:19.958] Packages needed by future strategies (n = 0): <none>
[17:29:19.959] {
[17:29:19.959]     {
[17:29:19.959]         {
[17:29:19.959]             ...future.startTime <- base::Sys.time()
[17:29:19.959]             {
[17:29:19.959]                 {
[17:29:19.959]                   {
[17:29:19.959]                     {
[17:29:19.959]                       base::local({
[17:29:19.959]                         has_future <- base::requireNamespace("future", 
[17:29:19.959]                           quietly = TRUE)
[17:29:19.959]                         if (has_future) {
[17:29:19.959]                           ns <- base::getNamespace("future")
[17:29:19.959]                           version <- ns[[".package"]][["version"]]
[17:29:19.959]                           if (is.null(version)) 
[17:29:19.959]                             version <- utils::packageVersion("future")
[17:29:19.959]                         }
[17:29:19.959]                         else {
[17:29:19.959]                           version <- NULL
[17:29:19.959]                         }
[17:29:19.959]                         if (!has_future || version < "1.8.0") {
[17:29:19.959]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:19.959]                             "", base::R.version$version.string), 
[17:29:19.959]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:19.959]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:19.959]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:19.959]                               "release", "version")], collapse = " "), 
[17:29:19.959]                             hostname = base::Sys.info()[["nodename"]])
[17:29:19.959]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:19.959]                             info)
[17:29:19.959]                           info <- base::paste(info, collapse = "; ")
[17:29:19.959]                           if (!has_future) {
[17:29:19.959]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:19.959]                               info)
[17:29:19.959]                           }
[17:29:19.959]                           else {
[17:29:19.959]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:19.959]                               info, version)
[17:29:19.959]                           }
[17:29:19.959]                           base::stop(msg)
[17:29:19.959]                         }
[17:29:19.959]                       })
[17:29:19.959]                     }
[17:29:19.959]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:19.959]                     base::options(mc.cores = 1L)
[17:29:19.959]                   }
[17:29:19.959]                   ...future.strategy.old <- future::plan("list")
[17:29:19.959]                   options(future.plan = NULL)
[17:29:19.959]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:19.959]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:19.959]                 }
[17:29:19.959]                 ...future.workdir <- getwd()
[17:29:19.959]             }
[17:29:19.959]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:19.959]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:19.959]         }
[17:29:19.959]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:19.959]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:19.959]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:19.959]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:19.959]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:19.959]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:19.959]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:19.959]             base::names(...future.oldOptions))
[17:29:19.959]     }
[17:29:19.959]     if (FALSE) {
[17:29:19.959]     }
[17:29:19.959]     else {
[17:29:19.959]         if (TRUE) {
[17:29:19.959]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:19.959]                 open = "w")
[17:29:19.959]         }
[17:29:19.959]         else {
[17:29:19.959]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:19.959]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:19.959]         }
[17:29:19.959]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:19.959]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:19.959]             base::sink(type = "output", split = FALSE)
[17:29:19.959]             base::close(...future.stdout)
[17:29:19.959]         }, add = TRUE)
[17:29:19.959]     }
[17:29:19.959]     ...future.frame <- base::sys.nframe()
[17:29:19.959]     ...future.conditions <- base::list()
[17:29:19.959]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:19.959]     if (FALSE) {
[17:29:19.959]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:19.959]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:19.959]     }
[17:29:19.959]     ...future.result <- base::tryCatch({
[17:29:19.959]         base::withCallingHandlers({
[17:29:19.959]             ...future.value <- base::withVisible(base::local({
[17:29:19.959]                 ...future.makeSendCondition <- base::local({
[17:29:19.959]                   sendCondition <- NULL
[17:29:19.959]                   function(frame = 1L) {
[17:29:19.959]                     if (is.function(sendCondition)) 
[17:29:19.959]                       return(sendCondition)
[17:29:19.959]                     ns <- getNamespace("parallel")
[17:29:19.959]                     if (exists("sendData", mode = "function", 
[17:29:19.959]                       envir = ns)) {
[17:29:19.959]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:19.959]                         envir = ns)
[17:29:19.959]                       envir <- sys.frame(frame)
[17:29:19.959]                       master <- NULL
[17:29:19.959]                       while (!identical(envir, .GlobalEnv) && 
[17:29:19.959]                         !identical(envir, emptyenv())) {
[17:29:19.959]                         if (exists("master", mode = "list", envir = envir, 
[17:29:19.959]                           inherits = FALSE)) {
[17:29:19.959]                           master <- get("master", mode = "list", 
[17:29:19.959]                             envir = envir, inherits = FALSE)
[17:29:19.959]                           if (inherits(master, c("SOCKnode", 
[17:29:19.959]                             "SOCK0node"))) {
[17:29:19.959]                             sendCondition <<- function(cond) {
[17:29:19.959]                               data <- list(type = "VALUE", value = cond, 
[17:29:19.959]                                 success = TRUE)
[17:29:19.959]                               parallel_sendData(master, data)
[17:29:19.959]                             }
[17:29:19.959]                             return(sendCondition)
[17:29:19.959]                           }
[17:29:19.959]                         }
[17:29:19.959]                         frame <- frame + 1L
[17:29:19.959]                         envir <- sys.frame(frame)
[17:29:19.959]                       }
[17:29:19.959]                     }
[17:29:19.959]                     sendCondition <<- function(cond) NULL
[17:29:19.959]                   }
[17:29:19.959]                 })
[17:29:19.959]                 withCallingHandlers({
[17:29:19.959]                   list(a = 1, b = 42L, c = stop("Nah!"))
[17:29:19.959]                 }, immediateCondition = function(cond) {
[17:29:19.959]                   sendCondition <- ...future.makeSendCondition()
[17:29:19.959]                   sendCondition(cond)
[17:29:19.959]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:19.959]                   {
[17:29:19.959]                     inherits <- base::inherits
[17:29:19.959]                     invokeRestart <- base::invokeRestart
[17:29:19.959]                     is.null <- base::is.null
[17:29:19.959]                     muffled <- FALSE
[17:29:19.959]                     if (inherits(cond, "message")) {
[17:29:19.959]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:19.959]                       if (muffled) 
[17:29:19.959]                         invokeRestart("muffleMessage")
[17:29:19.959]                     }
[17:29:19.959]                     else if (inherits(cond, "warning")) {
[17:29:19.959]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:19.959]                       if (muffled) 
[17:29:19.959]                         invokeRestart("muffleWarning")
[17:29:19.959]                     }
[17:29:19.959]                     else if (inherits(cond, "condition")) {
[17:29:19.959]                       if (!is.null(pattern)) {
[17:29:19.959]                         computeRestarts <- base::computeRestarts
[17:29:19.959]                         grepl <- base::grepl
[17:29:19.959]                         restarts <- computeRestarts(cond)
[17:29:19.959]                         for (restart in restarts) {
[17:29:19.959]                           name <- restart$name
[17:29:19.959]                           if (is.null(name)) 
[17:29:19.959]                             next
[17:29:19.959]                           if (!grepl(pattern, name)) 
[17:29:19.959]                             next
[17:29:19.959]                           invokeRestart(restart)
[17:29:19.959]                           muffled <- TRUE
[17:29:19.959]                           break
[17:29:19.959]                         }
[17:29:19.959]                       }
[17:29:19.959]                     }
[17:29:19.959]                     invisible(muffled)
[17:29:19.959]                   }
[17:29:19.959]                   muffleCondition(cond)
[17:29:19.959]                 })
[17:29:19.959]             }))
[17:29:19.959]             future::FutureResult(value = ...future.value$value, 
[17:29:19.959]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:19.959]                   ...future.rng), globalenv = if (FALSE) 
[17:29:19.959]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:19.959]                     ...future.globalenv.names))
[17:29:19.959]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:19.959]         }, condition = base::local({
[17:29:19.959]             c <- base::c
[17:29:19.959]             inherits <- base::inherits
[17:29:19.959]             invokeRestart <- base::invokeRestart
[17:29:19.959]             length <- base::length
[17:29:19.959]             list <- base::list
[17:29:19.959]             seq.int <- base::seq.int
[17:29:19.959]             signalCondition <- base::signalCondition
[17:29:19.959]             sys.calls <- base::sys.calls
[17:29:19.959]             `[[` <- base::`[[`
[17:29:19.959]             `+` <- base::`+`
[17:29:19.959]             `<<-` <- base::`<<-`
[17:29:19.959]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:19.959]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:19.959]                   3L)]
[17:29:19.959]             }
[17:29:19.959]             function(cond) {
[17:29:19.959]                 is_error <- inherits(cond, "error")
[17:29:19.959]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:19.959]                   NULL)
[17:29:19.959]                 if (is_error) {
[17:29:19.959]                   sessionInformation <- function() {
[17:29:19.959]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:19.959]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:19.959]                       search = base::search(), system = base::Sys.info())
[17:29:19.959]                   }
[17:29:19.959]                   ...future.conditions[[length(...future.conditions) + 
[17:29:19.959]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:19.959]                     cond$call), session = sessionInformation(), 
[17:29:19.959]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:19.959]                   signalCondition(cond)
[17:29:19.959]                 }
[17:29:19.959]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:19.959]                 "immediateCondition"))) {
[17:29:19.959]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:19.959]                   ...future.conditions[[length(...future.conditions) + 
[17:29:19.959]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:19.959]                   if (TRUE && !signal) {
[17:29:19.959]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:19.959]                     {
[17:29:19.959]                       inherits <- base::inherits
[17:29:19.959]                       invokeRestart <- base::invokeRestart
[17:29:19.959]                       is.null <- base::is.null
[17:29:19.959]                       muffled <- FALSE
[17:29:19.959]                       if (inherits(cond, "message")) {
[17:29:19.959]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:19.959]                         if (muffled) 
[17:29:19.959]                           invokeRestart("muffleMessage")
[17:29:19.959]                       }
[17:29:19.959]                       else if (inherits(cond, "warning")) {
[17:29:19.959]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:19.959]                         if (muffled) 
[17:29:19.959]                           invokeRestart("muffleWarning")
[17:29:19.959]                       }
[17:29:19.959]                       else if (inherits(cond, "condition")) {
[17:29:19.959]                         if (!is.null(pattern)) {
[17:29:19.959]                           computeRestarts <- base::computeRestarts
[17:29:19.959]                           grepl <- base::grepl
[17:29:19.959]                           restarts <- computeRestarts(cond)
[17:29:19.959]                           for (restart in restarts) {
[17:29:19.959]                             name <- restart$name
[17:29:19.959]                             if (is.null(name)) 
[17:29:19.959]                               next
[17:29:19.959]                             if (!grepl(pattern, name)) 
[17:29:19.959]                               next
[17:29:19.959]                             invokeRestart(restart)
[17:29:19.959]                             muffled <- TRUE
[17:29:19.959]                             break
[17:29:19.959]                           }
[17:29:19.959]                         }
[17:29:19.959]                       }
[17:29:19.959]                       invisible(muffled)
[17:29:19.959]                     }
[17:29:19.959]                     muffleCondition(cond, pattern = "^muffle")
[17:29:19.959]                   }
[17:29:19.959]                 }
[17:29:19.959]                 else {
[17:29:19.959]                   if (TRUE) {
[17:29:19.959]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:19.959]                     {
[17:29:19.959]                       inherits <- base::inherits
[17:29:19.959]                       invokeRestart <- base::invokeRestart
[17:29:19.959]                       is.null <- base::is.null
[17:29:19.959]                       muffled <- FALSE
[17:29:19.959]                       if (inherits(cond, "message")) {
[17:29:19.959]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:19.959]                         if (muffled) 
[17:29:19.959]                           invokeRestart("muffleMessage")
[17:29:19.959]                       }
[17:29:19.959]                       else if (inherits(cond, "warning")) {
[17:29:19.959]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:19.959]                         if (muffled) 
[17:29:19.959]                           invokeRestart("muffleWarning")
[17:29:19.959]                       }
[17:29:19.959]                       else if (inherits(cond, "condition")) {
[17:29:19.959]                         if (!is.null(pattern)) {
[17:29:19.959]                           computeRestarts <- base::computeRestarts
[17:29:19.959]                           grepl <- base::grepl
[17:29:19.959]                           restarts <- computeRestarts(cond)
[17:29:19.959]                           for (restart in restarts) {
[17:29:19.959]                             name <- restart$name
[17:29:19.959]                             if (is.null(name)) 
[17:29:19.959]                               next
[17:29:19.959]                             if (!grepl(pattern, name)) 
[17:29:19.959]                               next
[17:29:19.959]                             invokeRestart(restart)
[17:29:19.959]                             muffled <- TRUE
[17:29:19.959]                             break
[17:29:19.959]                           }
[17:29:19.959]                         }
[17:29:19.959]                       }
[17:29:19.959]                       invisible(muffled)
[17:29:19.959]                     }
[17:29:19.959]                     muffleCondition(cond, pattern = "^muffle")
[17:29:19.959]                   }
[17:29:19.959]                 }
[17:29:19.959]             }
[17:29:19.959]         }))
[17:29:19.959]     }, error = function(ex) {
[17:29:19.959]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:19.959]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:19.959]                 ...future.rng), started = ...future.startTime, 
[17:29:19.959]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:19.959]             version = "1.8"), class = "FutureResult")
[17:29:19.959]     }, finally = {
[17:29:19.959]         if (!identical(...future.workdir, getwd())) 
[17:29:19.959]             setwd(...future.workdir)
[17:29:19.959]         {
[17:29:19.959]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:19.959]                 ...future.oldOptions$nwarnings <- NULL
[17:29:19.959]             }
[17:29:19.959]             base::options(...future.oldOptions)
[17:29:19.959]             if (.Platform$OS.type == "windows") {
[17:29:19.959]                 old_names <- names(...future.oldEnvVars)
[17:29:19.959]                 envs <- base::Sys.getenv()
[17:29:19.959]                 names <- names(envs)
[17:29:19.959]                 common <- intersect(names, old_names)
[17:29:19.959]                 added <- setdiff(names, old_names)
[17:29:19.959]                 removed <- setdiff(old_names, names)
[17:29:19.959]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:19.959]                   envs[common]]
[17:29:19.959]                 NAMES <- toupper(changed)
[17:29:19.959]                 args <- list()
[17:29:19.959]                 for (kk in seq_along(NAMES)) {
[17:29:19.959]                   name <- changed[[kk]]
[17:29:19.959]                   NAME <- NAMES[[kk]]
[17:29:19.959]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:19.959]                     next
[17:29:19.959]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:19.959]                 }
[17:29:19.959]                 NAMES <- toupper(added)
[17:29:19.959]                 for (kk in seq_along(NAMES)) {
[17:29:19.959]                   name <- added[[kk]]
[17:29:19.959]                   NAME <- NAMES[[kk]]
[17:29:19.959]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:19.959]                     next
[17:29:19.959]                   args[[name]] <- ""
[17:29:19.959]                 }
[17:29:19.959]                 NAMES <- toupper(removed)
[17:29:19.959]                 for (kk in seq_along(NAMES)) {
[17:29:19.959]                   name <- removed[[kk]]
[17:29:19.959]                   NAME <- NAMES[[kk]]
[17:29:19.959]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:19.959]                     next
[17:29:19.959]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:19.959]                 }
[17:29:19.959]                 if (length(args) > 0) 
[17:29:19.959]                   base::do.call(base::Sys.setenv, args = args)
[17:29:19.959]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:19.959]             }
[17:29:19.959]             else {
[17:29:19.959]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:19.959]             }
[17:29:19.959]             {
[17:29:19.959]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:19.959]                   0L) {
[17:29:19.959]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:19.959]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:19.959]                   base::options(opts)
[17:29:19.959]                 }
[17:29:19.959]                 {
[17:29:19.959]                   {
[17:29:19.959]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:19.959]                     NULL
[17:29:19.959]                   }
[17:29:19.959]                   options(future.plan = NULL)
[17:29:19.959]                   if (is.na(NA_character_)) 
[17:29:19.959]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:19.959]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:19.959]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:19.959]                     .init = FALSE)
[17:29:19.959]                 }
[17:29:19.959]             }
[17:29:19.959]         }
[17:29:19.959]     })
[17:29:19.959]     if (TRUE) {
[17:29:19.959]         base::sink(type = "output", split = FALSE)
[17:29:19.959]         if (TRUE) {
[17:29:19.959]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:19.959]         }
[17:29:19.959]         else {
[17:29:19.959]             ...future.result["stdout"] <- base::list(NULL)
[17:29:19.959]         }
[17:29:19.959]         base::close(...future.stdout)
[17:29:19.959]         ...future.stdout <- NULL
[17:29:19.959]     }
[17:29:19.959]     ...future.result$conditions <- ...future.conditions
[17:29:19.959]     ...future.result$finished <- base::Sys.time()
[17:29:19.959]     ...future.result
[17:29:19.959] }
[17:29:19.968] MultisessionFuture started
[17:29:19.968] - Launch lazy future ... done
[17:29:19.968] run() for 'MultisessionFuture' ... done
[17:29:19.992] receiveMessageFromWorker() for ClusterFuture ...
[17:29:19.993] - Validating connection of MultisessionFuture
[17:29:19.994] - received message: FutureResult
[17:29:19.994] - Received FutureResult
[17:29:19.994] - Erased future from FutureRegistry
[17:29:19.995] result() for ClusterFuture ...
[17:29:19.995] - result already collected: FutureResult
[17:29:19.995] result() for ClusterFuture ... done
[17:29:19.996] signalConditions() ...
[17:29:19.996]  - include = 'immediateCondition'
[17:29:19.996]  - exclude = 
[17:29:19.997]  - resignal = FALSE
[17:29:19.997]  - Number of conditions: 1
[17:29:19.997] signalConditions() ... done
[17:29:19.998] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:19.998] A MultisessionFuture was resolved
[17:29:19.998] getGlobalsAndPackages() ...
[17:29:19.998] Searching for globals...
[17:29:20.000] - globals found: [2] 'list', 'stop'
[17:29:20.000] Searching for globals ... DONE
[17:29:20.001] Resolving globals: FALSE
[17:29:20.001] 
[17:29:20.002] 
[17:29:20.002] getGlobalsAndPackages() ... DONE
[17:29:20.002] run() for 'Future' ...
[17:29:20.003] - state: 'created'
[17:29:20.003] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:20.023] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:20.023] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:20.024]   - Field: 'node'
[17:29:20.024]   - Field: 'label'
[17:29:20.024]   - Field: 'local'
[17:29:20.025]   - Field: 'owner'
[17:29:20.025]   - Field: 'envir'
[17:29:20.026]   - Field: 'workers'
[17:29:20.026]   - Field: 'packages'
[17:29:20.026]   - Field: 'gc'
[17:29:20.026]   - Field: 'conditions'
[17:29:20.027]   - Field: 'persistent'
[17:29:20.027]   - Field: 'expr'
[17:29:20.027]   - Field: 'uuid'
[17:29:20.028]   - Field: 'seed'
[17:29:20.028]   - Field: 'version'
[17:29:20.028]   - Field: 'result'
[17:29:20.029]   - Field: 'asynchronous'
[17:29:20.029]   - Field: 'calls'
[17:29:20.029]   - Field: 'globals'
[17:29:20.030]   - Field: 'stdout'
[17:29:20.030]   - Field: 'earlySignal'
[17:29:20.030]   - Field: 'lazy'
[17:29:20.030]   - Field: 'state'
[17:29:20.031] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:20.031] - Launch lazy future ...
[17:29:20.032] Packages needed by the future expression (n = 0): <none>
[17:29:20.032] Packages needed by future strategies (n = 0): <none>
[17:29:20.033] {
[17:29:20.033]     {
[17:29:20.033]         {
[17:29:20.033]             ...future.startTime <- base::Sys.time()
[17:29:20.033]             {
[17:29:20.033]                 {
[17:29:20.033]                   {
[17:29:20.033]                     {
[17:29:20.033]                       base::local({
[17:29:20.033]                         has_future <- base::requireNamespace("future", 
[17:29:20.033]                           quietly = TRUE)
[17:29:20.033]                         if (has_future) {
[17:29:20.033]                           ns <- base::getNamespace("future")
[17:29:20.033]                           version <- ns[[".package"]][["version"]]
[17:29:20.033]                           if (is.null(version)) 
[17:29:20.033]                             version <- utils::packageVersion("future")
[17:29:20.033]                         }
[17:29:20.033]                         else {
[17:29:20.033]                           version <- NULL
[17:29:20.033]                         }
[17:29:20.033]                         if (!has_future || version < "1.8.0") {
[17:29:20.033]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:20.033]                             "", base::R.version$version.string), 
[17:29:20.033]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:20.033]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:20.033]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:20.033]                               "release", "version")], collapse = " "), 
[17:29:20.033]                             hostname = base::Sys.info()[["nodename"]])
[17:29:20.033]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:20.033]                             info)
[17:29:20.033]                           info <- base::paste(info, collapse = "; ")
[17:29:20.033]                           if (!has_future) {
[17:29:20.033]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:20.033]                               info)
[17:29:20.033]                           }
[17:29:20.033]                           else {
[17:29:20.033]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:20.033]                               info, version)
[17:29:20.033]                           }
[17:29:20.033]                           base::stop(msg)
[17:29:20.033]                         }
[17:29:20.033]                       })
[17:29:20.033]                     }
[17:29:20.033]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:20.033]                     base::options(mc.cores = 1L)
[17:29:20.033]                   }
[17:29:20.033]                   ...future.strategy.old <- future::plan("list")
[17:29:20.033]                   options(future.plan = NULL)
[17:29:20.033]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:20.033]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:20.033]                 }
[17:29:20.033]                 ...future.workdir <- getwd()
[17:29:20.033]             }
[17:29:20.033]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:20.033]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:20.033]         }
[17:29:20.033]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:20.033]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:20.033]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:20.033]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:20.033]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:20.033]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:20.033]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:20.033]             base::names(...future.oldOptions))
[17:29:20.033]     }
[17:29:20.033]     if (FALSE) {
[17:29:20.033]     }
[17:29:20.033]     else {
[17:29:20.033]         if (TRUE) {
[17:29:20.033]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:20.033]                 open = "w")
[17:29:20.033]         }
[17:29:20.033]         else {
[17:29:20.033]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:20.033]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:20.033]         }
[17:29:20.033]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:20.033]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:20.033]             base::sink(type = "output", split = FALSE)
[17:29:20.033]             base::close(...future.stdout)
[17:29:20.033]         }, add = TRUE)
[17:29:20.033]     }
[17:29:20.033]     ...future.frame <- base::sys.nframe()
[17:29:20.033]     ...future.conditions <- base::list()
[17:29:20.033]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:20.033]     if (FALSE) {
[17:29:20.033]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:20.033]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:20.033]     }
[17:29:20.033]     ...future.result <- base::tryCatch({
[17:29:20.033]         base::withCallingHandlers({
[17:29:20.033]             ...future.value <- base::withVisible(base::local({
[17:29:20.033]                 ...future.makeSendCondition <- base::local({
[17:29:20.033]                   sendCondition <- NULL
[17:29:20.033]                   function(frame = 1L) {
[17:29:20.033]                     if (is.function(sendCondition)) 
[17:29:20.033]                       return(sendCondition)
[17:29:20.033]                     ns <- getNamespace("parallel")
[17:29:20.033]                     if (exists("sendData", mode = "function", 
[17:29:20.033]                       envir = ns)) {
[17:29:20.033]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:20.033]                         envir = ns)
[17:29:20.033]                       envir <- sys.frame(frame)
[17:29:20.033]                       master <- NULL
[17:29:20.033]                       while (!identical(envir, .GlobalEnv) && 
[17:29:20.033]                         !identical(envir, emptyenv())) {
[17:29:20.033]                         if (exists("master", mode = "list", envir = envir, 
[17:29:20.033]                           inherits = FALSE)) {
[17:29:20.033]                           master <- get("master", mode = "list", 
[17:29:20.033]                             envir = envir, inherits = FALSE)
[17:29:20.033]                           if (inherits(master, c("SOCKnode", 
[17:29:20.033]                             "SOCK0node"))) {
[17:29:20.033]                             sendCondition <<- function(cond) {
[17:29:20.033]                               data <- list(type = "VALUE", value = cond, 
[17:29:20.033]                                 success = TRUE)
[17:29:20.033]                               parallel_sendData(master, data)
[17:29:20.033]                             }
[17:29:20.033]                             return(sendCondition)
[17:29:20.033]                           }
[17:29:20.033]                         }
[17:29:20.033]                         frame <- frame + 1L
[17:29:20.033]                         envir <- sys.frame(frame)
[17:29:20.033]                       }
[17:29:20.033]                     }
[17:29:20.033]                     sendCondition <<- function(cond) NULL
[17:29:20.033]                   }
[17:29:20.033]                 })
[17:29:20.033]                 withCallingHandlers({
[17:29:20.033]                   list(a = 1, b = 42L, c = stop("Nah!"))
[17:29:20.033]                 }, immediateCondition = function(cond) {
[17:29:20.033]                   sendCondition <- ...future.makeSendCondition()
[17:29:20.033]                   sendCondition(cond)
[17:29:20.033]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:20.033]                   {
[17:29:20.033]                     inherits <- base::inherits
[17:29:20.033]                     invokeRestart <- base::invokeRestart
[17:29:20.033]                     is.null <- base::is.null
[17:29:20.033]                     muffled <- FALSE
[17:29:20.033]                     if (inherits(cond, "message")) {
[17:29:20.033]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:20.033]                       if (muffled) 
[17:29:20.033]                         invokeRestart("muffleMessage")
[17:29:20.033]                     }
[17:29:20.033]                     else if (inherits(cond, "warning")) {
[17:29:20.033]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:20.033]                       if (muffled) 
[17:29:20.033]                         invokeRestart("muffleWarning")
[17:29:20.033]                     }
[17:29:20.033]                     else if (inherits(cond, "condition")) {
[17:29:20.033]                       if (!is.null(pattern)) {
[17:29:20.033]                         computeRestarts <- base::computeRestarts
[17:29:20.033]                         grepl <- base::grepl
[17:29:20.033]                         restarts <- computeRestarts(cond)
[17:29:20.033]                         for (restart in restarts) {
[17:29:20.033]                           name <- restart$name
[17:29:20.033]                           if (is.null(name)) 
[17:29:20.033]                             next
[17:29:20.033]                           if (!grepl(pattern, name)) 
[17:29:20.033]                             next
[17:29:20.033]                           invokeRestart(restart)
[17:29:20.033]                           muffled <- TRUE
[17:29:20.033]                           break
[17:29:20.033]                         }
[17:29:20.033]                       }
[17:29:20.033]                     }
[17:29:20.033]                     invisible(muffled)
[17:29:20.033]                   }
[17:29:20.033]                   muffleCondition(cond)
[17:29:20.033]                 })
[17:29:20.033]             }))
[17:29:20.033]             future::FutureResult(value = ...future.value$value, 
[17:29:20.033]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:20.033]                   ...future.rng), globalenv = if (FALSE) 
[17:29:20.033]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:20.033]                     ...future.globalenv.names))
[17:29:20.033]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:20.033]         }, condition = base::local({
[17:29:20.033]             c <- base::c
[17:29:20.033]             inherits <- base::inherits
[17:29:20.033]             invokeRestart <- base::invokeRestart
[17:29:20.033]             length <- base::length
[17:29:20.033]             list <- base::list
[17:29:20.033]             seq.int <- base::seq.int
[17:29:20.033]             signalCondition <- base::signalCondition
[17:29:20.033]             sys.calls <- base::sys.calls
[17:29:20.033]             `[[` <- base::`[[`
[17:29:20.033]             `+` <- base::`+`
[17:29:20.033]             `<<-` <- base::`<<-`
[17:29:20.033]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:20.033]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:20.033]                   3L)]
[17:29:20.033]             }
[17:29:20.033]             function(cond) {
[17:29:20.033]                 is_error <- inherits(cond, "error")
[17:29:20.033]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:20.033]                   NULL)
[17:29:20.033]                 if (is_error) {
[17:29:20.033]                   sessionInformation <- function() {
[17:29:20.033]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:20.033]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:20.033]                       search = base::search(), system = base::Sys.info())
[17:29:20.033]                   }
[17:29:20.033]                   ...future.conditions[[length(...future.conditions) + 
[17:29:20.033]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:20.033]                     cond$call), session = sessionInformation(), 
[17:29:20.033]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:20.033]                   signalCondition(cond)
[17:29:20.033]                 }
[17:29:20.033]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:20.033]                 "immediateCondition"))) {
[17:29:20.033]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:20.033]                   ...future.conditions[[length(...future.conditions) + 
[17:29:20.033]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:20.033]                   if (TRUE && !signal) {
[17:29:20.033]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:20.033]                     {
[17:29:20.033]                       inherits <- base::inherits
[17:29:20.033]                       invokeRestart <- base::invokeRestart
[17:29:20.033]                       is.null <- base::is.null
[17:29:20.033]                       muffled <- FALSE
[17:29:20.033]                       if (inherits(cond, "message")) {
[17:29:20.033]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:20.033]                         if (muffled) 
[17:29:20.033]                           invokeRestart("muffleMessage")
[17:29:20.033]                       }
[17:29:20.033]                       else if (inherits(cond, "warning")) {
[17:29:20.033]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:20.033]                         if (muffled) 
[17:29:20.033]                           invokeRestart("muffleWarning")
[17:29:20.033]                       }
[17:29:20.033]                       else if (inherits(cond, "condition")) {
[17:29:20.033]                         if (!is.null(pattern)) {
[17:29:20.033]                           computeRestarts <- base::computeRestarts
[17:29:20.033]                           grepl <- base::grepl
[17:29:20.033]                           restarts <- computeRestarts(cond)
[17:29:20.033]                           for (restart in restarts) {
[17:29:20.033]                             name <- restart$name
[17:29:20.033]                             if (is.null(name)) 
[17:29:20.033]                               next
[17:29:20.033]                             if (!grepl(pattern, name)) 
[17:29:20.033]                               next
[17:29:20.033]                             invokeRestart(restart)
[17:29:20.033]                             muffled <- TRUE
[17:29:20.033]                             break
[17:29:20.033]                           }
[17:29:20.033]                         }
[17:29:20.033]                       }
[17:29:20.033]                       invisible(muffled)
[17:29:20.033]                     }
[17:29:20.033]                     muffleCondition(cond, pattern = "^muffle")
[17:29:20.033]                   }
[17:29:20.033]                 }
[17:29:20.033]                 else {
[17:29:20.033]                   if (TRUE) {
[17:29:20.033]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:20.033]                     {
[17:29:20.033]                       inherits <- base::inherits
[17:29:20.033]                       invokeRestart <- base::invokeRestart
[17:29:20.033]                       is.null <- base::is.null
[17:29:20.033]                       muffled <- FALSE
[17:29:20.033]                       if (inherits(cond, "message")) {
[17:29:20.033]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:20.033]                         if (muffled) 
[17:29:20.033]                           invokeRestart("muffleMessage")
[17:29:20.033]                       }
[17:29:20.033]                       else if (inherits(cond, "warning")) {
[17:29:20.033]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:20.033]                         if (muffled) 
[17:29:20.033]                           invokeRestart("muffleWarning")
[17:29:20.033]                       }
[17:29:20.033]                       else if (inherits(cond, "condition")) {
[17:29:20.033]                         if (!is.null(pattern)) {
[17:29:20.033]                           computeRestarts <- base::computeRestarts
[17:29:20.033]                           grepl <- base::grepl
[17:29:20.033]                           restarts <- computeRestarts(cond)
[17:29:20.033]                           for (restart in restarts) {
[17:29:20.033]                             name <- restart$name
[17:29:20.033]                             if (is.null(name)) 
[17:29:20.033]                               next
[17:29:20.033]                             if (!grepl(pattern, name)) 
[17:29:20.033]                               next
[17:29:20.033]                             invokeRestart(restart)
[17:29:20.033]                             muffled <- TRUE
[17:29:20.033]                             break
[17:29:20.033]                           }
[17:29:20.033]                         }
[17:29:20.033]                       }
[17:29:20.033]                       invisible(muffled)
[17:29:20.033]                     }
[17:29:20.033]                     muffleCondition(cond, pattern = "^muffle")
[17:29:20.033]                   }
[17:29:20.033]                 }
[17:29:20.033]             }
[17:29:20.033]         }))
[17:29:20.033]     }, error = function(ex) {
[17:29:20.033]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:20.033]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:20.033]                 ...future.rng), started = ...future.startTime, 
[17:29:20.033]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:20.033]             version = "1.8"), class = "FutureResult")
[17:29:20.033]     }, finally = {
[17:29:20.033]         if (!identical(...future.workdir, getwd())) 
[17:29:20.033]             setwd(...future.workdir)
[17:29:20.033]         {
[17:29:20.033]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:20.033]                 ...future.oldOptions$nwarnings <- NULL
[17:29:20.033]             }
[17:29:20.033]             base::options(...future.oldOptions)
[17:29:20.033]             if (.Platform$OS.type == "windows") {
[17:29:20.033]                 old_names <- names(...future.oldEnvVars)
[17:29:20.033]                 envs <- base::Sys.getenv()
[17:29:20.033]                 names <- names(envs)
[17:29:20.033]                 common <- intersect(names, old_names)
[17:29:20.033]                 added <- setdiff(names, old_names)
[17:29:20.033]                 removed <- setdiff(old_names, names)
[17:29:20.033]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:20.033]                   envs[common]]
[17:29:20.033]                 NAMES <- toupper(changed)
[17:29:20.033]                 args <- list()
[17:29:20.033]                 for (kk in seq_along(NAMES)) {
[17:29:20.033]                   name <- changed[[kk]]
[17:29:20.033]                   NAME <- NAMES[[kk]]
[17:29:20.033]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:20.033]                     next
[17:29:20.033]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:20.033]                 }
[17:29:20.033]                 NAMES <- toupper(added)
[17:29:20.033]                 for (kk in seq_along(NAMES)) {
[17:29:20.033]                   name <- added[[kk]]
[17:29:20.033]                   NAME <- NAMES[[kk]]
[17:29:20.033]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:20.033]                     next
[17:29:20.033]                   args[[name]] <- ""
[17:29:20.033]                 }
[17:29:20.033]                 NAMES <- toupper(removed)
[17:29:20.033]                 for (kk in seq_along(NAMES)) {
[17:29:20.033]                   name <- removed[[kk]]
[17:29:20.033]                   NAME <- NAMES[[kk]]
[17:29:20.033]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:20.033]                     next
[17:29:20.033]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:20.033]                 }
[17:29:20.033]                 if (length(args) > 0) 
[17:29:20.033]                   base::do.call(base::Sys.setenv, args = args)
[17:29:20.033]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:20.033]             }
[17:29:20.033]             else {
[17:29:20.033]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:20.033]             }
[17:29:20.033]             {
[17:29:20.033]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:20.033]                   0L) {
[17:29:20.033]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:20.033]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:20.033]                   base::options(opts)
[17:29:20.033]                 }
[17:29:20.033]                 {
[17:29:20.033]                   {
[17:29:20.033]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:20.033]                     NULL
[17:29:20.033]                   }
[17:29:20.033]                   options(future.plan = NULL)
[17:29:20.033]                   if (is.na(NA_character_)) 
[17:29:20.033]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:20.033]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:20.033]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:20.033]                     .init = FALSE)
[17:29:20.033]                 }
[17:29:20.033]             }
[17:29:20.033]         }
[17:29:20.033]     })
[17:29:20.033]     if (TRUE) {
[17:29:20.033]         base::sink(type = "output", split = FALSE)
[17:29:20.033]         if (TRUE) {
[17:29:20.033]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:20.033]         }
[17:29:20.033]         else {
[17:29:20.033]             ...future.result["stdout"] <- base::list(NULL)
[17:29:20.033]         }
[17:29:20.033]         base::close(...future.stdout)
[17:29:20.033]         ...future.stdout <- NULL
[17:29:20.033]     }
[17:29:20.033]     ...future.result$conditions <- ...future.conditions
[17:29:20.033]     ...future.result$finished <- base::Sys.time()
[17:29:20.033]     ...future.result
[17:29:20.033] }
[17:29:20.043] MultisessionFuture started
[17:29:20.044] - Launch lazy future ... done
[17:29:20.044] run() for 'MultisessionFuture' ... done
[17:29:20.062] receiveMessageFromWorker() for ClusterFuture ...
[17:29:20.062] - Validating connection of MultisessionFuture
[17:29:20.063] - received message: FutureResult
[17:29:20.064] - Received FutureResult
[17:29:20.064] - Erased future from FutureRegistry
[17:29:20.064] result() for ClusterFuture ...
[17:29:20.064] - result already collected: FutureResult
[17:29:20.065] result() for ClusterFuture ... done
[17:29:20.065] signalConditions() ...
[17:29:20.065]  - include = 'immediateCondition'
[17:29:20.065]  - exclude = 
[17:29:20.066]  - resignal = FALSE
[17:29:20.066]  - Number of conditions: 1
[17:29:20.066] signalConditions() ... done
[17:29:20.066] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:20.067] A MultisessionFuture was resolved
- result = TRUE, recursive = 0 ... DONE
- result = TRUE, recursive = 1 ...
[17:29:20.067] getGlobalsAndPackages() ...
[17:29:20.067] Searching for globals...
[17:29:20.070] - globals found: [3] '{', 'Sys.sleep', 'list'
[17:29:20.070] Searching for globals ... DONE
[17:29:20.070] Resolving globals: FALSE
[17:29:20.071] 
[17:29:20.071] 
[17:29:20.071] getGlobalsAndPackages() ... DONE
[17:29:20.072] run() for 'Future' ...
[17:29:20.072] - state: 'created'
[17:29:20.073] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:20.092] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:20.092] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:20.093]   - Field: 'node'
[17:29:20.093]   - Field: 'label'
[17:29:20.093]   - Field: 'local'
[17:29:20.093]   - Field: 'owner'
[17:29:20.094]   - Field: 'envir'
[17:29:20.094]   - Field: 'workers'
[17:29:20.094]   - Field: 'packages'
[17:29:20.095]   - Field: 'gc'
[17:29:20.095]   - Field: 'conditions'
[17:29:20.095]   - Field: 'persistent'
[17:29:20.095]   - Field: 'expr'
[17:29:20.099]   - Field: 'uuid'
[17:29:20.100]   - Field: 'seed'
[17:29:20.100]   - Field: 'version'
[17:29:20.100]   - Field: 'result'
[17:29:20.101]   - Field: 'asynchronous'
[17:29:20.101]   - Field: 'calls'
[17:29:20.101]   - Field: 'globals'
[17:29:20.101]   - Field: 'stdout'
[17:29:20.102]   - Field: 'earlySignal'
[17:29:20.102]   - Field: 'lazy'
[17:29:20.102]   - Field: 'state'
[17:29:20.102] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:20.103] - Launch lazy future ...
[17:29:20.103] Packages needed by the future expression (n = 0): <none>
[17:29:20.104] Packages needed by future strategies (n = 0): <none>
[17:29:20.104] {
[17:29:20.104]     {
[17:29:20.104]         {
[17:29:20.104]             ...future.startTime <- base::Sys.time()
[17:29:20.104]             {
[17:29:20.104]                 {
[17:29:20.104]                   {
[17:29:20.104]                     {
[17:29:20.104]                       base::local({
[17:29:20.104]                         has_future <- base::requireNamespace("future", 
[17:29:20.104]                           quietly = TRUE)
[17:29:20.104]                         if (has_future) {
[17:29:20.104]                           ns <- base::getNamespace("future")
[17:29:20.104]                           version <- ns[[".package"]][["version"]]
[17:29:20.104]                           if (is.null(version)) 
[17:29:20.104]                             version <- utils::packageVersion("future")
[17:29:20.104]                         }
[17:29:20.104]                         else {
[17:29:20.104]                           version <- NULL
[17:29:20.104]                         }
[17:29:20.104]                         if (!has_future || version < "1.8.0") {
[17:29:20.104]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:20.104]                             "", base::R.version$version.string), 
[17:29:20.104]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:20.104]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:20.104]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:20.104]                               "release", "version")], collapse = " "), 
[17:29:20.104]                             hostname = base::Sys.info()[["nodename"]])
[17:29:20.104]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:20.104]                             info)
[17:29:20.104]                           info <- base::paste(info, collapse = "; ")
[17:29:20.104]                           if (!has_future) {
[17:29:20.104]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:20.104]                               info)
[17:29:20.104]                           }
[17:29:20.104]                           else {
[17:29:20.104]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:20.104]                               info, version)
[17:29:20.104]                           }
[17:29:20.104]                           base::stop(msg)
[17:29:20.104]                         }
[17:29:20.104]                       })
[17:29:20.104]                     }
[17:29:20.104]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:20.104]                     base::options(mc.cores = 1L)
[17:29:20.104]                   }
[17:29:20.104]                   ...future.strategy.old <- future::plan("list")
[17:29:20.104]                   options(future.plan = NULL)
[17:29:20.104]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:20.104]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:20.104]                 }
[17:29:20.104]                 ...future.workdir <- getwd()
[17:29:20.104]             }
[17:29:20.104]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:20.104]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:20.104]         }
[17:29:20.104]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:20.104]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:20.104]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:20.104]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:20.104]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:20.104]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:20.104]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:20.104]             base::names(...future.oldOptions))
[17:29:20.104]     }
[17:29:20.104]     if (FALSE) {
[17:29:20.104]     }
[17:29:20.104]     else {
[17:29:20.104]         if (TRUE) {
[17:29:20.104]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:20.104]                 open = "w")
[17:29:20.104]         }
[17:29:20.104]         else {
[17:29:20.104]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:20.104]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:20.104]         }
[17:29:20.104]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:20.104]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:20.104]             base::sink(type = "output", split = FALSE)
[17:29:20.104]             base::close(...future.stdout)
[17:29:20.104]         }, add = TRUE)
[17:29:20.104]     }
[17:29:20.104]     ...future.frame <- base::sys.nframe()
[17:29:20.104]     ...future.conditions <- base::list()
[17:29:20.104]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:20.104]     if (FALSE) {
[17:29:20.104]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:20.104]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:20.104]     }
[17:29:20.104]     ...future.result <- base::tryCatch({
[17:29:20.104]         base::withCallingHandlers({
[17:29:20.104]             ...future.value <- base::withVisible(base::local({
[17:29:20.104]                 ...future.makeSendCondition <- base::local({
[17:29:20.104]                   sendCondition <- NULL
[17:29:20.104]                   function(frame = 1L) {
[17:29:20.104]                     if (is.function(sendCondition)) 
[17:29:20.104]                       return(sendCondition)
[17:29:20.104]                     ns <- getNamespace("parallel")
[17:29:20.104]                     if (exists("sendData", mode = "function", 
[17:29:20.104]                       envir = ns)) {
[17:29:20.104]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:20.104]                         envir = ns)
[17:29:20.104]                       envir <- sys.frame(frame)
[17:29:20.104]                       master <- NULL
[17:29:20.104]                       while (!identical(envir, .GlobalEnv) && 
[17:29:20.104]                         !identical(envir, emptyenv())) {
[17:29:20.104]                         if (exists("master", mode = "list", envir = envir, 
[17:29:20.104]                           inherits = FALSE)) {
[17:29:20.104]                           master <- get("master", mode = "list", 
[17:29:20.104]                             envir = envir, inherits = FALSE)
[17:29:20.104]                           if (inherits(master, c("SOCKnode", 
[17:29:20.104]                             "SOCK0node"))) {
[17:29:20.104]                             sendCondition <<- function(cond) {
[17:29:20.104]                               data <- list(type = "VALUE", value = cond, 
[17:29:20.104]                                 success = TRUE)
[17:29:20.104]                               parallel_sendData(master, data)
[17:29:20.104]                             }
[17:29:20.104]                             return(sendCondition)
[17:29:20.104]                           }
[17:29:20.104]                         }
[17:29:20.104]                         frame <- frame + 1L
[17:29:20.104]                         envir <- sys.frame(frame)
[17:29:20.104]                       }
[17:29:20.104]                     }
[17:29:20.104]                     sendCondition <<- function(cond) NULL
[17:29:20.104]                   }
[17:29:20.104]                 })
[17:29:20.104]                 withCallingHandlers({
[17:29:20.104]                   {
[17:29:20.104]                     Sys.sleep(0.5)
[17:29:20.104]                     list(a = 1, b = 42L)
[17:29:20.104]                   }
[17:29:20.104]                 }, immediateCondition = function(cond) {
[17:29:20.104]                   sendCondition <- ...future.makeSendCondition()
[17:29:20.104]                   sendCondition(cond)
[17:29:20.104]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:20.104]                   {
[17:29:20.104]                     inherits <- base::inherits
[17:29:20.104]                     invokeRestart <- base::invokeRestart
[17:29:20.104]                     is.null <- base::is.null
[17:29:20.104]                     muffled <- FALSE
[17:29:20.104]                     if (inherits(cond, "message")) {
[17:29:20.104]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:20.104]                       if (muffled) 
[17:29:20.104]                         invokeRestart("muffleMessage")
[17:29:20.104]                     }
[17:29:20.104]                     else if (inherits(cond, "warning")) {
[17:29:20.104]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:20.104]                       if (muffled) 
[17:29:20.104]                         invokeRestart("muffleWarning")
[17:29:20.104]                     }
[17:29:20.104]                     else if (inherits(cond, "condition")) {
[17:29:20.104]                       if (!is.null(pattern)) {
[17:29:20.104]                         computeRestarts <- base::computeRestarts
[17:29:20.104]                         grepl <- base::grepl
[17:29:20.104]                         restarts <- computeRestarts(cond)
[17:29:20.104]                         for (restart in restarts) {
[17:29:20.104]                           name <- restart$name
[17:29:20.104]                           if (is.null(name)) 
[17:29:20.104]                             next
[17:29:20.104]                           if (!grepl(pattern, name)) 
[17:29:20.104]                             next
[17:29:20.104]                           invokeRestart(restart)
[17:29:20.104]                           muffled <- TRUE
[17:29:20.104]                           break
[17:29:20.104]                         }
[17:29:20.104]                       }
[17:29:20.104]                     }
[17:29:20.104]                     invisible(muffled)
[17:29:20.104]                   }
[17:29:20.104]                   muffleCondition(cond)
[17:29:20.104]                 })
[17:29:20.104]             }))
[17:29:20.104]             future::FutureResult(value = ...future.value$value, 
[17:29:20.104]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:20.104]                   ...future.rng), globalenv = if (FALSE) 
[17:29:20.104]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:20.104]                     ...future.globalenv.names))
[17:29:20.104]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:20.104]         }, condition = base::local({
[17:29:20.104]             c <- base::c
[17:29:20.104]             inherits <- base::inherits
[17:29:20.104]             invokeRestart <- base::invokeRestart
[17:29:20.104]             length <- base::length
[17:29:20.104]             list <- base::list
[17:29:20.104]             seq.int <- base::seq.int
[17:29:20.104]             signalCondition <- base::signalCondition
[17:29:20.104]             sys.calls <- base::sys.calls
[17:29:20.104]             `[[` <- base::`[[`
[17:29:20.104]             `+` <- base::`+`
[17:29:20.104]             `<<-` <- base::`<<-`
[17:29:20.104]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:20.104]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:20.104]                   3L)]
[17:29:20.104]             }
[17:29:20.104]             function(cond) {
[17:29:20.104]                 is_error <- inherits(cond, "error")
[17:29:20.104]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:20.104]                   NULL)
[17:29:20.104]                 if (is_error) {
[17:29:20.104]                   sessionInformation <- function() {
[17:29:20.104]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:20.104]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:20.104]                       search = base::search(), system = base::Sys.info())
[17:29:20.104]                   }
[17:29:20.104]                   ...future.conditions[[length(...future.conditions) + 
[17:29:20.104]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:20.104]                     cond$call), session = sessionInformation(), 
[17:29:20.104]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:20.104]                   signalCondition(cond)
[17:29:20.104]                 }
[17:29:20.104]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:20.104]                 "immediateCondition"))) {
[17:29:20.104]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:20.104]                   ...future.conditions[[length(...future.conditions) + 
[17:29:20.104]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:20.104]                   if (TRUE && !signal) {
[17:29:20.104]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:20.104]                     {
[17:29:20.104]                       inherits <- base::inherits
[17:29:20.104]                       invokeRestart <- base::invokeRestart
[17:29:20.104]                       is.null <- base::is.null
[17:29:20.104]                       muffled <- FALSE
[17:29:20.104]                       if (inherits(cond, "message")) {
[17:29:20.104]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:20.104]                         if (muffled) 
[17:29:20.104]                           invokeRestart("muffleMessage")
[17:29:20.104]                       }
[17:29:20.104]                       else if (inherits(cond, "warning")) {
[17:29:20.104]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:20.104]                         if (muffled) 
[17:29:20.104]                           invokeRestart("muffleWarning")
[17:29:20.104]                       }
[17:29:20.104]                       else if (inherits(cond, "condition")) {
[17:29:20.104]                         if (!is.null(pattern)) {
[17:29:20.104]                           computeRestarts <- base::computeRestarts
[17:29:20.104]                           grepl <- base::grepl
[17:29:20.104]                           restarts <- computeRestarts(cond)
[17:29:20.104]                           for (restart in restarts) {
[17:29:20.104]                             name <- restart$name
[17:29:20.104]                             if (is.null(name)) 
[17:29:20.104]                               next
[17:29:20.104]                             if (!grepl(pattern, name)) 
[17:29:20.104]                               next
[17:29:20.104]                             invokeRestart(restart)
[17:29:20.104]                             muffled <- TRUE
[17:29:20.104]                             break
[17:29:20.104]                           }
[17:29:20.104]                         }
[17:29:20.104]                       }
[17:29:20.104]                       invisible(muffled)
[17:29:20.104]                     }
[17:29:20.104]                     muffleCondition(cond, pattern = "^muffle")
[17:29:20.104]                   }
[17:29:20.104]                 }
[17:29:20.104]                 else {
[17:29:20.104]                   if (TRUE) {
[17:29:20.104]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:20.104]                     {
[17:29:20.104]                       inherits <- base::inherits
[17:29:20.104]                       invokeRestart <- base::invokeRestart
[17:29:20.104]                       is.null <- base::is.null
[17:29:20.104]                       muffled <- FALSE
[17:29:20.104]                       if (inherits(cond, "message")) {
[17:29:20.104]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:20.104]                         if (muffled) 
[17:29:20.104]                           invokeRestart("muffleMessage")
[17:29:20.104]                       }
[17:29:20.104]                       else if (inherits(cond, "warning")) {
[17:29:20.104]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:20.104]                         if (muffled) 
[17:29:20.104]                           invokeRestart("muffleWarning")
[17:29:20.104]                       }
[17:29:20.104]                       else if (inherits(cond, "condition")) {
[17:29:20.104]                         if (!is.null(pattern)) {
[17:29:20.104]                           computeRestarts <- base::computeRestarts
[17:29:20.104]                           grepl <- base::grepl
[17:29:20.104]                           restarts <- computeRestarts(cond)
[17:29:20.104]                           for (restart in restarts) {
[17:29:20.104]                             name <- restart$name
[17:29:20.104]                             if (is.null(name)) 
[17:29:20.104]                               next
[17:29:20.104]                             if (!grepl(pattern, name)) 
[17:29:20.104]                               next
[17:29:20.104]                             invokeRestart(restart)
[17:29:20.104]                             muffled <- TRUE
[17:29:20.104]                             break
[17:29:20.104]                           }
[17:29:20.104]                         }
[17:29:20.104]                       }
[17:29:20.104]                       invisible(muffled)
[17:29:20.104]                     }
[17:29:20.104]                     muffleCondition(cond, pattern = "^muffle")
[17:29:20.104]                   }
[17:29:20.104]                 }
[17:29:20.104]             }
[17:29:20.104]         }))
[17:29:20.104]     }, error = function(ex) {
[17:29:20.104]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:20.104]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:20.104]                 ...future.rng), started = ...future.startTime, 
[17:29:20.104]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:20.104]             version = "1.8"), class = "FutureResult")
[17:29:20.104]     }, finally = {
[17:29:20.104]         if (!identical(...future.workdir, getwd())) 
[17:29:20.104]             setwd(...future.workdir)
[17:29:20.104]         {
[17:29:20.104]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:20.104]                 ...future.oldOptions$nwarnings <- NULL
[17:29:20.104]             }
[17:29:20.104]             base::options(...future.oldOptions)
[17:29:20.104]             if (.Platform$OS.type == "windows") {
[17:29:20.104]                 old_names <- names(...future.oldEnvVars)
[17:29:20.104]                 envs <- base::Sys.getenv()
[17:29:20.104]                 names <- names(envs)
[17:29:20.104]                 common <- intersect(names, old_names)
[17:29:20.104]                 added <- setdiff(names, old_names)
[17:29:20.104]                 removed <- setdiff(old_names, names)
[17:29:20.104]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:20.104]                   envs[common]]
[17:29:20.104]                 NAMES <- toupper(changed)
[17:29:20.104]                 args <- list()
[17:29:20.104]                 for (kk in seq_along(NAMES)) {
[17:29:20.104]                   name <- changed[[kk]]
[17:29:20.104]                   NAME <- NAMES[[kk]]
[17:29:20.104]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:20.104]                     next
[17:29:20.104]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:20.104]                 }
[17:29:20.104]                 NAMES <- toupper(added)
[17:29:20.104]                 for (kk in seq_along(NAMES)) {
[17:29:20.104]                   name <- added[[kk]]
[17:29:20.104]                   NAME <- NAMES[[kk]]
[17:29:20.104]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:20.104]                     next
[17:29:20.104]                   args[[name]] <- ""
[17:29:20.104]                 }
[17:29:20.104]                 NAMES <- toupper(removed)
[17:29:20.104]                 for (kk in seq_along(NAMES)) {
[17:29:20.104]                   name <- removed[[kk]]
[17:29:20.104]                   NAME <- NAMES[[kk]]
[17:29:20.104]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:20.104]                     next
[17:29:20.104]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:20.104]                 }
[17:29:20.104]                 if (length(args) > 0) 
[17:29:20.104]                   base::do.call(base::Sys.setenv, args = args)
[17:29:20.104]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:20.104]             }
[17:29:20.104]             else {
[17:29:20.104]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:20.104]             }
[17:29:20.104]             {
[17:29:20.104]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:20.104]                   0L) {
[17:29:20.104]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:20.104]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:20.104]                   base::options(opts)
[17:29:20.104]                 }
[17:29:20.104]                 {
[17:29:20.104]                   {
[17:29:20.104]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:20.104]                     NULL
[17:29:20.104]                   }
[17:29:20.104]                   options(future.plan = NULL)
[17:29:20.104]                   if (is.na(NA_character_)) 
[17:29:20.104]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:20.104]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:20.104]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:20.104]                     .init = FALSE)
[17:29:20.104]                 }
[17:29:20.104]             }
[17:29:20.104]         }
[17:29:20.104]     })
[17:29:20.104]     if (TRUE) {
[17:29:20.104]         base::sink(type = "output", split = FALSE)
[17:29:20.104]         if (TRUE) {
[17:29:20.104]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:20.104]         }
[17:29:20.104]         else {
[17:29:20.104]             ...future.result["stdout"] <- base::list(NULL)
[17:29:20.104]         }
[17:29:20.104]         base::close(...future.stdout)
[17:29:20.104]         ...future.stdout <- NULL
[17:29:20.104]     }
[17:29:20.104]     ...future.result$conditions <- ...future.conditions
[17:29:20.104]     ...future.result$finished <- base::Sys.time()
[17:29:20.104]     ...future.result
[17:29:20.104] }
[17:29:20.114] MultisessionFuture started
[17:29:20.114] - Launch lazy future ... done
[17:29:20.114] run() for 'MultisessionFuture' ... done
[17:29:20.652] receiveMessageFromWorker() for ClusterFuture ...
[17:29:20.653] - Validating connection of MultisessionFuture
[17:29:20.653] - received message: FutureResult
[17:29:20.654] - Received FutureResult
[17:29:20.654] - Erased future from FutureRegistry
[17:29:20.654] result() for ClusterFuture ...
[17:29:20.654] - result already collected: FutureResult
[17:29:20.655] result() for ClusterFuture ... done
[17:29:20.655] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:20.655] resolve() on list ...
[17:29:20.655]  recursive: 0
[17:29:20.655]  length: 2
[17:29:20.656]  elements: 'a', 'b'
[17:29:20.656]  length: 1 (resolved future 1)
[17:29:20.656]  length: 0 (resolved future 2)
[17:29:20.656] resolve() on list ... DONE
[17:29:20.657] A MultisessionFuture was resolved (and resolved itself)
[17:29:20.657] getGlobalsAndPackages() ...
[17:29:20.657] Searching for globals...
[17:29:20.659] - globals found: [3] '{', 'Sys.sleep', 'list'
[17:29:20.659] Searching for globals ... DONE
[17:29:20.659] Resolving globals: FALSE
[17:29:20.660] 
[17:29:20.660] 
[17:29:20.660] getGlobalsAndPackages() ... DONE
[17:29:20.660] run() for 'Future' ...
[17:29:20.661] - state: 'created'
[17:29:20.661] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:20.676] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:20.677] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:20.677]   - Field: 'node'
[17:29:20.677]   - Field: 'label'
[17:29:20.677]   - Field: 'local'
[17:29:20.678]   - Field: 'owner'
[17:29:20.678]   - Field: 'envir'
[17:29:20.678]   - Field: 'workers'
[17:29:20.678]   - Field: 'packages'
[17:29:20.679]   - Field: 'gc'
[17:29:20.679]   - Field: 'conditions'
[17:29:20.679]   - Field: 'persistent'
[17:29:20.679]   - Field: 'expr'
[17:29:20.680]   - Field: 'uuid'
[17:29:20.680]   - Field: 'seed'
[17:29:20.680]   - Field: 'version'
[17:29:20.680]   - Field: 'result'
[17:29:20.681]   - Field: 'asynchronous'
[17:29:20.681]   - Field: 'calls'
[17:29:20.681]   - Field: 'globals'
[17:29:20.681]   - Field: 'stdout'
[17:29:20.681]   - Field: 'earlySignal'
[17:29:20.681]   - Field: 'lazy'
[17:29:20.682]   - Field: 'state'
[17:29:20.682] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:20.682] - Launch lazy future ...
[17:29:20.682] Packages needed by the future expression (n = 0): <none>
[17:29:20.683] Packages needed by future strategies (n = 0): <none>
[17:29:20.683] {
[17:29:20.683]     {
[17:29:20.683]         {
[17:29:20.683]             ...future.startTime <- base::Sys.time()
[17:29:20.683]             {
[17:29:20.683]                 {
[17:29:20.683]                   {
[17:29:20.683]                     {
[17:29:20.683]                       base::local({
[17:29:20.683]                         has_future <- base::requireNamespace("future", 
[17:29:20.683]                           quietly = TRUE)
[17:29:20.683]                         if (has_future) {
[17:29:20.683]                           ns <- base::getNamespace("future")
[17:29:20.683]                           version <- ns[[".package"]][["version"]]
[17:29:20.683]                           if (is.null(version)) 
[17:29:20.683]                             version <- utils::packageVersion("future")
[17:29:20.683]                         }
[17:29:20.683]                         else {
[17:29:20.683]                           version <- NULL
[17:29:20.683]                         }
[17:29:20.683]                         if (!has_future || version < "1.8.0") {
[17:29:20.683]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:20.683]                             "", base::R.version$version.string), 
[17:29:20.683]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:20.683]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:20.683]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:20.683]                               "release", "version")], collapse = " "), 
[17:29:20.683]                             hostname = base::Sys.info()[["nodename"]])
[17:29:20.683]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:20.683]                             info)
[17:29:20.683]                           info <- base::paste(info, collapse = "; ")
[17:29:20.683]                           if (!has_future) {
[17:29:20.683]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:20.683]                               info)
[17:29:20.683]                           }
[17:29:20.683]                           else {
[17:29:20.683]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:20.683]                               info, version)
[17:29:20.683]                           }
[17:29:20.683]                           base::stop(msg)
[17:29:20.683]                         }
[17:29:20.683]                       })
[17:29:20.683]                     }
[17:29:20.683]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:20.683]                     base::options(mc.cores = 1L)
[17:29:20.683]                   }
[17:29:20.683]                   ...future.strategy.old <- future::plan("list")
[17:29:20.683]                   options(future.plan = NULL)
[17:29:20.683]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:20.683]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:20.683]                 }
[17:29:20.683]                 ...future.workdir <- getwd()
[17:29:20.683]             }
[17:29:20.683]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:20.683]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:20.683]         }
[17:29:20.683]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:20.683]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:20.683]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:20.683]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:20.683]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:20.683]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:20.683]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:20.683]             base::names(...future.oldOptions))
[17:29:20.683]     }
[17:29:20.683]     if (FALSE) {
[17:29:20.683]     }
[17:29:20.683]     else {
[17:29:20.683]         if (TRUE) {
[17:29:20.683]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:20.683]                 open = "w")
[17:29:20.683]         }
[17:29:20.683]         else {
[17:29:20.683]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:20.683]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:20.683]         }
[17:29:20.683]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:20.683]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:20.683]             base::sink(type = "output", split = FALSE)
[17:29:20.683]             base::close(...future.stdout)
[17:29:20.683]         }, add = TRUE)
[17:29:20.683]     }
[17:29:20.683]     ...future.frame <- base::sys.nframe()
[17:29:20.683]     ...future.conditions <- base::list()
[17:29:20.683]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:20.683]     if (FALSE) {
[17:29:20.683]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:20.683]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:20.683]     }
[17:29:20.683]     ...future.result <- base::tryCatch({
[17:29:20.683]         base::withCallingHandlers({
[17:29:20.683]             ...future.value <- base::withVisible(base::local({
[17:29:20.683]                 ...future.makeSendCondition <- base::local({
[17:29:20.683]                   sendCondition <- NULL
[17:29:20.683]                   function(frame = 1L) {
[17:29:20.683]                     if (is.function(sendCondition)) 
[17:29:20.683]                       return(sendCondition)
[17:29:20.683]                     ns <- getNamespace("parallel")
[17:29:20.683]                     if (exists("sendData", mode = "function", 
[17:29:20.683]                       envir = ns)) {
[17:29:20.683]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:20.683]                         envir = ns)
[17:29:20.683]                       envir <- sys.frame(frame)
[17:29:20.683]                       master <- NULL
[17:29:20.683]                       while (!identical(envir, .GlobalEnv) && 
[17:29:20.683]                         !identical(envir, emptyenv())) {
[17:29:20.683]                         if (exists("master", mode = "list", envir = envir, 
[17:29:20.683]                           inherits = FALSE)) {
[17:29:20.683]                           master <- get("master", mode = "list", 
[17:29:20.683]                             envir = envir, inherits = FALSE)
[17:29:20.683]                           if (inherits(master, c("SOCKnode", 
[17:29:20.683]                             "SOCK0node"))) {
[17:29:20.683]                             sendCondition <<- function(cond) {
[17:29:20.683]                               data <- list(type = "VALUE", value = cond, 
[17:29:20.683]                                 success = TRUE)
[17:29:20.683]                               parallel_sendData(master, data)
[17:29:20.683]                             }
[17:29:20.683]                             return(sendCondition)
[17:29:20.683]                           }
[17:29:20.683]                         }
[17:29:20.683]                         frame <- frame + 1L
[17:29:20.683]                         envir <- sys.frame(frame)
[17:29:20.683]                       }
[17:29:20.683]                     }
[17:29:20.683]                     sendCondition <<- function(cond) NULL
[17:29:20.683]                   }
[17:29:20.683]                 })
[17:29:20.683]                 withCallingHandlers({
[17:29:20.683]                   {
[17:29:20.683]                     Sys.sleep(0.5)
[17:29:20.683]                     list(a = 1, b = 42L)
[17:29:20.683]                   }
[17:29:20.683]                 }, immediateCondition = function(cond) {
[17:29:20.683]                   sendCondition <- ...future.makeSendCondition()
[17:29:20.683]                   sendCondition(cond)
[17:29:20.683]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:20.683]                   {
[17:29:20.683]                     inherits <- base::inherits
[17:29:20.683]                     invokeRestart <- base::invokeRestart
[17:29:20.683]                     is.null <- base::is.null
[17:29:20.683]                     muffled <- FALSE
[17:29:20.683]                     if (inherits(cond, "message")) {
[17:29:20.683]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:20.683]                       if (muffled) 
[17:29:20.683]                         invokeRestart("muffleMessage")
[17:29:20.683]                     }
[17:29:20.683]                     else if (inherits(cond, "warning")) {
[17:29:20.683]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:20.683]                       if (muffled) 
[17:29:20.683]                         invokeRestart("muffleWarning")
[17:29:20.683]                     }
[17:29:20.683]                     else if (inherits(cond, "condition")) {
[17:29:20.683]                       if (!is.null(pattern)) {
[17:29:20.683]                         computeRestarts <- base::computeRestarts
[17:29:20.683]                         grepl <- base::grepl
[17:29:20.683]                         restarts <- computeRestarts(cond)
[17:29:20.683]                         for (restart in restarts) {
[17:29:20.683]                           name <- restart$name
[17:29:20.683]                           if (is.null(name)) 
[17:29:20.683]                             next
[17:29:20.683]                           if (!grepl(pattern, name)) 
[17:29:20.683]                             next
[17:29:20.683]                           invokeRestart(restart)
[17:29:20.683]                           muffled <- TRUE
[17:29:20.683]                           break
[17:29:20.683]                         }
[17:29:20.683]                       }
[17:29:20.683]                     }
[17:29:20.683]                     invisible(muffled)
[17:29:20.683]                   }
[17:29:20.683]                   muffleCondition(cond)
[17:29:20.683]                 })
[17:29:20.683]             }))
[17:29:20.683]             future::FutureResult(value = ...future.value$value, 
[17:29:20.683]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:20.683]                   ...future.rng), globalenv = if (FALSE) 
[17:29:20.683]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:20.683]                     ...future.globalenv.names))
[17:29:20.683]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:20.683]         }, condition = base::local({
[17:29:20.683]             c <- base::c
[17:29:20.683]             inherits <- base::inherits
[17:29:20.683]             invokeRestart <- base::invokeRestart
[17:29:20.683]             length <- base::length
[17:29:20.683]             list <- base::list
[17:29:20.683]             seq.int <- base::seq.int
[17:29:20.683]             signalCondition <- base::signalCondition
[17:29:20.683]             sys.calls <- base::sys.calls
[17:29:20.683]             `[[` <- base::`[[`
[17:29:20.683]             `+` <- base::`+`
[17:29:20.683]             `<<-` <- base::`<<-`
[17:29:20.683]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:20.683]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:20.683]                   3L)]
[17:29:20.683]             }
[17:29:20.683]             function(cond) {
[17:29:20.683]                 is_error <- inherits(cond, "error")
[17:29:20.683]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:20.683]                   NULL)
[17:29:20.683]                 if (is_error) {
[17:29:20.683]                   sessionInformation <- function() {
[17:29:20.683]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:20.683]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:20.683]                       search = base::search(), system = base::Sys.info())
[17:29:20.683]                   }
[17:29:20.683]                   ...future.conditions[[length(...future.conditions) + 
[17:29:20.683]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:20.683]                     cond$call), session = sessionInformation(), 
[17:29:20.683]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:20.683]                   signalCondition(cond)
[17:29:20.683]                 }
[17:29:20.683]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:20.683]                 "immediateCondition"))) {
[17:29:20.683]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:20.683]                   ...future.conditions[[length(...future.conditions) + 
[17:29:20.683]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:20.683]                   if (TRUE && !signal) {
[17:29:20.683]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:20.683]                     {
[17:29:20.683]                       inherits <- base::inherits
[17:29:20.683]                       invokeRestart <- base::invokeRestart
[17:29:20.683]                       is.null <- base::is.null
[17:29:20.683]                       muffled <- FALSE
[17:29:20.683]                       if (inherits(cond, "message")) {
[17:29:20.683]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:20.683]                         if (muffled) 
[17:29:20.683]                           invokeRestart("muffleMessage")
[17:29:20.683]                       }
[17:29:20.683]                       else if (inherits(cond, "warning")) {
[17:29:20.683]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:20.683]                         if (muffled) 
[17:29:20.683]                           invokeRestart("muffleWarning")
[17:29:20.683]                       }
[17:29:20.683]                       else if (inherits(cond, "condition")) {
[17:29:20.683]                         if (!is.null(pattern)) {
[17:29:20.683]                           computeRestarts <- base::computeRestarts
[17:29:20.683]                           grepl <- base::grepl
[17:29:20.683]                           restarts <- computeRestarts(cond)
[17:29:20.683]                           for (restart in restarts) {
[17:29:20.683]                             name <- restart$name
[17:29:20.683]                             if (is.null(name)) 
[17:29:20.683]                               next
[17:29:20.683]                             if (!grepl(pattern, name)) 
[17:29:20.683]                               next
[17:29:20.683]                             invokeRestart(restart)
[17:29:20.683]                             muffled <- TRUE
[17:29:20.683]                             break
[17:29:20.683]                           }
[17:29:20.683]                         }
[17:29:20.683]                       }
[17:29:20.683]                       invisible(muffled)
[17:29:20.683]                     }
[17:29:20.683]                     muffleCondition(cond, pattern = "^muffle")
[17:29:20.683]                   }
[17:29:20.683]                 }
[17:29:20.683]                 else {
[17:29:20.683]                   if (TRUE) {
[17:29:20.683]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:20.683]                     {
[17:29:20.683]                       inherits <- base::inherits
[17:29:20.683]                       invokeRestart <- base::invokeRestart
[17:29:20.683]                       is.null <- base::is.null
[17:29:20.683]                       muffled <- FALSE
[17:29:20.683]                       if (inherits(cond, "message")) {
[17:29:20.683]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:20.683]                         if (muffled) 
[17:29:20.683]                           invokeRestart("muffleMessage")
[17:29:20.683]                       }
[17:29:20.683]                       else if (inherits(cond, "warning")) {
[17:29:20.683]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:20.683]                         if (muffled) 
[17:29:20.683]                           invokeRestart("muffleWarning")
[17:29:20.683]                       }
[17:29:20.683]                       else if (inherits(cond, "condition")) {
[17:29:20.683]                         if (!is.null(pattern)) {
[17:29:20.683]                           computeRestarts <- base::computeRestarts
[17:29:20.683]                           grepl <- base::grepl
[17:29:20.683]                           restarts <- computeRestarts(cond)
[17:29:20.683]                           for (restart in restarts) {
[17:29:20.683]                             name <- restart$name
[17:29:20.683]                             if (is.null(name)) 
[17:29:20.683]                               next
[17:29:20.683]                             if (!grepl(pattern, name)) 
[17:29:20.683]                               next
[17:29:20.683]                             invokeRestart(restart)
[17:29:20.683]                             muffled <- TRUE
[17:29:20.683]                             break
[17:29:20.683]                           }
[17:29:20.683]                         }
[17:29:20.683]                       }
[17:29:20.683]                       invisible(muffled)
[17:29:20.683]                     }
[17:29:20.683]                     muffleCondition(cond, pattern = "^muffle")
[17:29:20.683]                   }
[17:29:20.683]                 }
[17:29:20.683]             }
[17:29:20.683]         }))
[17:29:20.683]     }, error = function(ex) {
[17:29:20.683]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:20.683]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:20.683]                 ...future.rng), started = ...future.startTime, 
[17:29:20.683]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:20.683]             version = "1.8"), class = "FutureResult")
[17:29:20.683]     }, finally = {
[17:29:20.683]         if (!identical(...future.workdir, getwd())) 
[17:29:20.683]             setwd(...future.workdir)
[17:29:20.683]         {
[17:29:20.683]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:20.683]                 ...future.oldOptions$nwarnings <- NULL
[17:29:20.683]             }
[17:29:20.683]             base::options(...future.oldOptions)
[17:29:20.683]             if (.Platform$OS.type == "windows") {
[17:29:20.683]                 old_names <- names(...future.oldEnvVars)
[17:29:20.683]                 envs <- base::Sys.getenv()
[17:29:20.683]                 names <- names(envs)
[17:29:20.683]                 common <- intersect(names, old_names)
[17:29:20.683]                 added <- setdiff(names, old_names)
[17:29:20.683]                 removed <- setdiff(old_names, names)
[17:29:20.683]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:20.683]                   envs[common]]
[17:29:20.683]                 NAMES <- toupper(changed)
[17:29:20.683]                 args <- list()
[17:29:20.683]                 for (kk in seq_along(NAMES)) {
[17:29:20.683]                   name <- changed[[kk]]
[17:29:20.683]                   NAME <- NAMES[[kk]]
[17:29:20.683]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:20.683]                     next
[17:29:20.683]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:20.683]                 }
[17:29:20.683]                 NAMES <- toupper(added)
[17:29:20.683]                 for (kk in seq_along(NAMES)) {
[17:29:20.683]                   name <- added[[kk]]
[17:29:20.683]                   NAME <- NAMES[[kk]]
[17:29:20.683]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:20.683]                     next
[17:29:20.683]                   args[[name]] <- ""
[17:29:20.683]                 }
[17:29:20.683]                 NAMES <- toupper(removed)
[17:29:20.683]                 for (kk in seq_along(NAMES)) {
[17:29:20.683]                   name <- removed[[kk]]
[17:29:20.683]                   NAME <- NAMES[[kk]]
[17:29:20.683]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:20.683]                     next
[17:29:20.683]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:20.683]                 }
[17:29:20.683]                 if (length(args) > 0) 
[17:29:20.683]                   base::do.call(base::Sys.setenv, args = args)
[17:29:20.683]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:20.683]             }
[17:29:20.683]             else {
[17:29:20.683]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:20.683]             }
[17:29:20.683]             {
[17:29:20.683]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:20.683]                   0L) {
[17:29:20.683]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:20.683]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:20.683]                   base::options(opts)
[17:29:20.683]                 }
[17:29:20.683]                 {
[17:29:20.683]                   {
[17:29:20.683]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:20.683]                     NULL
[17:29:20.683]                   }
[17:29:20.683]                   options(future.plan = NULL)
[17:29:20.683]                   if (is.na(NA_character_)) 
[17:29:20.683]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:20.683]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:20.683]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:20.683]                     .init = FALSE)
[17:29:20.683]                 }
[17:29:20.683]             }
[17:29:20.683]         }
[17:29:20.683]     })
[17:29:20.683]     if (TRUE) {
[17:29:20.683]         base::sink(type = "output", split = FALSE)
[17:29:20.683]         if (TRUE) {
[17:29:20.683]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:20.683]         }
[17:29:20.683]         else {
[17:29:20.683]             ...future.result["stdout"] <- base::list(NULL)
[17:29:20.683]         }
[17:29:20.683]         base::close(...future.stdout)
[17:29:20.683]         ...future.stdout <- NULL
[17:29:20.683]     }
[17:29:20.683]     ...future.result$conditions <- ...future.conditions
[17:29:20.683]     ...future.result$finished <- base::Sys.time()
[17:29:20.683]     ...future.result
[17:29:20.683] }
[17:29:20.692] MultisessionFuture started
[17:29:20.692] - Launch lazy future ... done
[17:29:20.693] run() for 'MultisessionFuture' ... done
[17:29:21.234] receiveMessageFromWorker() for ClusterFuture ...
[17:29:21.235] - Validating connection of MultisessionFuture
[17:29:21.235] - received message: FutureResult
[17:29:21.236] - Received FutureResult
[17:29:21.236] - Erased future from FutureRegistry
[17:29:21.236] result() for ClusterFuture ...
[17:29:21.237] - result already collected: FutureResult
[17:29:21.237] result() for ClusterFuture ... done
[17:29:21.237] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:21.238] resolve() on list ...
[17:29:21.238]  recursive: 0
[17:29:21.238]  length: 2
[17:29:21.238]  elements: 'a', 'b'
[17:29:21.239]  length: 1 (resolved future 1)
[17:29:21.239]  length: 0 (resolved future 2)
[17:29:21.239] resolve() on list ... DONE
[17:29:21.239] A MultisessionFuture was resolved (and resolved itself)
- w/ exception ...
[17:29:21.240] getGlobalsAndPackages() ...
[17:29:21.240] Searching for globals...
[17:29:21.241] - globals found: [2] 'list', 'stop'
[17:29:21.242] Searching for globals ... DONE
[17:29:21.242] Resolving globals: FALSE
[17:29:21.243] 
[17:29:21.243] 
[17:29:21.243] getGlobalsAndPackages() ... DONE
[17:29:21.244] run() for 'Future' ...
[17:29:21.244] - state: 'created'
[17:29:21.244] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:21.263] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:21.264] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:21.264]   - Field: 'node'
[17:29:21.265]   - Field: 'label'
[17:29:21.265]   - Field: 'local'
[17:29:21.265]   - Field: 'owner'
[17:29:21.265]   - Field: 'envir'
[17:29:21.266]   - Field: 'workers'
[17:29:21.266]   - Field: 'packages'
[17:29:21.266]   - Field: 'gc'
[17:29:21.267]   - Field: 'conditions'
[17:29:21.267]   - Field: 'persistent'
[17:29:21.267]   - Field: 'expr'
[17:29:21.268]   - Field: 'uuid'
[17:29:21.268]   - Field: 'seed'
[17:29:21.268]   - Field: 'version'
[17:29:21.269]   - Field: 'result'
[17:29:21.269]   - Field: 'asynchronous'
[17:29:21.269]   - Field: 'calls'
[17:29:21.269]   - Field: 'globals'
[17:29:21.270]   - Field: 'stdout'
[17:29:21.270]   - Field: 'earlySignal'
[17:29:21.270]   - Field: 'lazy'
[17:29:21.271]   - Field: 'state'
[17:29:21.271] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:21.271] - Launch lazy future ...
[17:29:21.272] Packages needed by the future expression (n = 0): <none>
[17:29:21.272] Packages needed by future strategies (n = 0): <none>
[17:29:21.273] {
[17:29:21.273]     {
[17:29:21.273]         {
[17:29:21.273]             ...future.startTime <- base::Sys.time()
[17:29:21.273]             {
[17:29:21.273]                 {
[17:29:21.273]                   {
[17:29:21.273]                     {
[17:29:21.273]                       base::local({
[17:29:21.273]                         has_future <- base::requireNamespace("future", 
[17:29:21.273]                           quietly = TRUE)
[17:29:21.273]                         if (has_future) {
[17:29:21.273]                           ns <- base::getNamespace("future")
[17:29:21.273]                           version <- ns[[".package"]][["version"]]
[17:29:21.273]                           if (is.null(version)) 
[17:29:21.273]                             version <- utils::packageVersion("future")
[17:29:21.273]                         }
[17:29:21.273]                         else {
[17:29:21.273]                           version <- NULL
[17:29:21.273]                         }
[17:29:21.273]                         if (!has_future || version < "1.8.0") {
[17:29:21.273]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:21.273]                             "", base::R.version$version.string), 
[17:29:21.273]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:21.273]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:21.273]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:21.273]                               "release", "version")], collapse = " "), 
[17:29:21.273]                             hostname = base::Sys.info()[["nodename"]])
[17:29:21.273]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:21.273]                             info)
[17:29:21.273]                           info <- base::paste(info, collapse = "; ")
[17:29:21.273]                           if (!has_future) {
[17:29:21.273]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:21.273]                               info)
[17:29:21.273]                           }
[17:29:21.273]                           else {
[17:29:21.273]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:21.273]                               info, version)
[17:29:21.273]                           }
[17:29:21.273]                           base::stop(msg)
[17:29:21.273]                         }
[17:29:21.273]                       })
[17:29:21.273]                     }
[17:29:21.273]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:21.273]                     base::options(mc.cores = 1L)
[17:29:21.273]                   }
[17:29:21.273]                   ...future.strategy.old <- future::plan("list")
[17:29:21.273]                   options(future.plan = NULL)
[17:29:21.273]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:21.273]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:21.273]                 }
[17:29:21.273]                 ...future.workdir <- getwd()
[17:29:21.273]             }
[17:29:21.273]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:21.273]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:21.273]         }
[17:29:21.273]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:21.273]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:21.273]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:21.273]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:21.273]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:21.273]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:21.273]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:21.273]             base::names(...future.oldOptions))
[17:29:21.273]     }
[17:29:21.273]     if (FALSE) {
[17:29:21.273]     }
[17:29:21.273]     else {
[17:29:21.273]         if (TRUE) {
[17:29:21.273]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:21.273]                 open = "w")
[17:29:21.273]         }
[17:29:21.273]         else {
[17:29:21.273]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:21.273]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:21.273]         }
[17:29:21.273]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:21.273]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:21.273]             base::sink(type = "output", split = FALSE)
[17:29:21.273]             base::close(...future.stdout)
[17:29:21.273]         }, add = TRUE)
[17:29:21.273]     }
[17:29:21.273]     ...future.frame <- base::sys.nframe()
[17:29:21.273]     ...future.conditions <- base::list()
[17:29:21.273]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:21.273]     if (FALSE) {
[17:29:21.273]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:21.273]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:21.273]     }
[17:29:21.273]     ...future.result <- base::tryCatch({
[17:29:21.273]         base::withCallingHandlers({
[17:29:21.273]             ...future.value <- base::withVisible(base::local({
[17:29:21.273]                 ...future.makeSendCondition <- base::local({
[17:29:21.273]                   sendCondition <- NULL
[17:29:21.273]                   function(frame = 1L) {
[17:29:21.273]                     if (is.function(sendCondition)) 
[17:29:21.273]                       return(sendCondition)
[17:29:21.273]                     ns <- getNamespace("parallel")
[17:29:21.273]                     if (exists("sendData", mode = "function", 
[17:29:21.273]                       envir = ns)) {
[17:29:21.273]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:21.273]                         envir = ns)
[17:29:21.273]                       envir <- sys.frame(frame)
[17:29:21.273]                       master <- NULL
[17:29:21.273]                       while (!identical(envir, .GlobalEnv) && 
[17:29:21.273]                         !identical(envir, emptyenv())) {
[17:29:21.273]                         if (exists("master", mode = "list", envir = envir, 
[17:29:21.273]                           inherits = FALSE)) {
[17:29:21.273]                           master <- get("master", mode = "list", 
[17:29:21.273]                             envir = envir, inherits = FALSE)
[17:29:21.273]                           if (inherits(master, c("SOCKnode", 
[17:29:21.273]                             "SOCK0node"))) {
[17:29:21.273]                             sendCondition <<- function(cond) {
[17:29:21.273]                               data <- list(type = "VALUE", value = cond, 
[17:29:21.273]                                 success = TRUE)
[17:29:21.273]                               parallel_sendData(master, data)
[17:29:21.273]                             }
[17:29:21.273]                             return(sendCondition)
[17:29:21.273]                           }
[17:29:21.273]                         }
[17:29:21.273]                         frame <- frame + 1L
[17:29:21.273]                         envir <- sys.frame(frame)
[17:29:21.273]                       }
[17:29:21.273]                     }
[17:29:21.273]                     sendCondition <<- function(cond) NULL
[17:29:21.273]                   }
[17:29:21.273]                 })
[17:29:21.273]                 withCallingHandlers({
[17:29:21.273]                   list(a = 1, b = 42L, c = stop("Nah!"))
[17:29:21.273]                 }, immediateCondition = function(cond) {
[17:29:21.273]                   sendCondition <- ...future.makeSendCondition()
[17:29:21.273]                   sendCondition(cond)
[17:29:21.273]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:21.273]                   {
[17:29:21.273]                     inherits <- base::inherits
[17:29:21.273]                     invokeRestart <- base::invokeRestart
[17:29:21.273]                     is.null <- base::is.null
[17:29:21.273]                     muffled <- FALSE
[17:29:21.273]                     if (inherits(cond, "message")) {
[17:29:21.273]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:21.273]                       if (muffled) 
[17:29:21.273]                         invokeRestart("muffleMessage")
[17:29:21.273]                     }
[17:29:21.273]                     else if (inherits(cond, "warning")) {
[17:29:21.273]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:21.273]                       if (muffled) 
[17:29:21.273]                         invokeRestart("muffleWarning")
[17:29:21.273]                     }
[17:29:21.273]                     else if (inherits(cond, "condition")) {
[17:29:21.273]                       if (!is.null(pattern)) {
[17:29:21.273]                         computeRestarts <- base::computeRestarts
[17:29:21.273]                         grepl <- base::grepl
[17:29:21.273]                         restarts <- computeRestarts(cond)
[17:29:21.273]                         for (restart in restarts) {
[17:29:21.273]                           name <- restart$name
[17:29:21.273]                           if (is.null(name)) 
[17:29:21.273]                             next
[17:29:21.273]                           if (!grepl(pattern, name)) 
[17:29:21.273]                             next
[17:29:21.273]                           invokeRestart(restart)
[17:29:21.273]                           muffled <- TRUE
[17:29:21.273]                           break
[17:29:21.273]                         }
[17:29:21.273]                       }
[17:29:21.273]                     }
[17:29:21.273]                     invisible(muffled)
[17:29:21.273]                   }
[17:29:21.273]                   muffleCondition(cond)
[17:29:21.273]                 })
[17:29:21.273]             }))
[17:29:21.273]             future::FutureResult(value = ...future.value$value, 
[17:29:21.273]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:21.273]                   ...future.rng), globalenv = if (FALSE) 
[17:29:21.273]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:21.273]                     ...future.globalenv.names))
[17:29:21.273]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:21.273]         }, condition = base::local({
[17:29:21.273]             c <- base::c
[17:29:21.273]             inherits <- base::inherits
[17:29:21.273]             invokeRestart <- base::invokeRestart
[17:29:21.273]             length <- base::length
[17:29:21.273]             list <- base::list
[17:29:21.273]             seq.int <- base::seq.int
[17:29:21.273]             signalCondition <- base::signalCondition
[17:29:21.273]             sys.calls <- base::sys.calls
[17:29:21.273]             `[[` <- base::`[[`
[17:29:21.273]             `+` <- base::`+`
[17:29:21.273]             `<<-` <- base::`<<-`
[17:29:21.273]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:21.273]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:21.273]                   3L)]
[17:29:21.273]             }
[17:29:21.273]             function(cond) {
[17:29:21.273]                 is_error <- inherits(cond, "error")
[17:29:21.273]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:21.273]                   NULL)
[17:29:21.273]                 if (is_error) {
[17:29:21.273]                   sessionInformation <- function() {
[17:29:21.273]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:21.273]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:21.273]                       search = base::search(), system = base::Sys.info())
[17:29:21.273]                   }
[17:29:21.273]                   ...future.conditions[[length(...future.conditions) + 
[17:29:21.273]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:21.273]                     cond$call), session = sessionInformation(), 
[17:29:21.273]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:21.273]                   signalCondition(cond)
[17:29:21.273]                 }
[17:29:21.273]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:21.273]                 "immediateCondition"))) {
[17:29:21.273]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:21.273]                   ...future.conditions[[length(...future.conditions) + 
[17:29:21.273]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:21.273]                   if (TRUE && !signal) {
[17:29:21.273]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:21.273]                     {
[17:29:21.273]                       inherits <- base::inherits
[17:29:21.273]                       invokeRestart <- base::invokeRestart
[17:29:21.273]                       is.null <- base::is.null
[17:29:21.273]                       muffled <- FALSE
[17:29:21.273]                       if (inherits(cond, "message")) {
[17:29:21.273]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:21.273]                         if (muffled) 
[17:29:21.273]                           invokeRestart("muffleMessage")
[17:29:21.273]                       }
[17:29:21.273]                       else if (inherits(cond, "warning")) {
[17:29:21.273]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:21.273]                         if (muffled) 
[17:29:21.273]                           invokeRestart("muffleWarning")
[17:29:21.273]                       }
[17:29:21.273]                       else if (inherits(cond, "condition")) {
[17:29:21.273]                         if (!is.null(pattern)) {
[17:29:21.273]                           computeRestarts <- base::computeRestarts
[17:29:21.273]                           grepl <- base::grepl
[17:29:21.273]                           restarts <- computeRestarts(cond)
[17:29:21.273]                           for (restart in restarts) {
[17:29:21.273]                             name <- restart$name
[17:29:21.273]                             if (is.null(name)) 
[17:29:21.273]                               next
[17:29:21.273]                             if (!grepl(pattern, name)) 
[17:29:21.273]                               next
[17:29:21.273]                             invokeRestart(restart)
[17:29:21.273]                             muffled <- TRUE
[17:29:21.273]                             break
[17:29:21.273]                           }
[17:29:21.273]                         }
[17:29:21.273]                       }
[17:29:21.273]                       invisible(muffled)
[17:29:21.273]                     }
[17:29:21.273]                     muffleCondition(cond, pattern = "^muffle")
[17:29:21.273]                   }
[17:29:21.273]                 }
[17:29:21.273]                 else {
[17:29:21.273]                   if (TRUE) {
[17:29:21.273]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:21.273]                     {
[17:29:21.273]                       inherits <- base::inherits
[17:29:21.273]                       invokeRestart <- base::invokeRestart
[17:29:21.273]                       is.null <- base::is.null
[17:29:21.273]                       muffled <- FALSE
[17:29:21.273]                       if (inherits(cond, "message")) {
[17:29:21.273]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:21.273]                         if (muffled) 
[17:29:21.273]                           invokeRestart("muffleMessage")
[17:29:21.273]                       }
[17:29:21.273]                       else if (inherits(cond, "warning")) {
[17:29:21.273]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:21.273]                         if (muffled) 
[17:29:21.273]                           invokeRestart("muffleWarning")
[17:29:21.273]                       }
[17:29:21.273]                       else if (inherits(cond, "condition")) {
[17:29:21.273]                         if (!is.null(pattern)) {
[17:29:21.273]                           computeRestarts <- base::computeRestarts
[17:29:21.273]                           grepl <- base::grepl
[17:29:21.273]                           restarts <- computeRestarts(cond)
[17:29:21.273]                           for (restart in restarts) {
[17:29:21.273]                             name <- restart$name
[17:29:21.273]                             if (is.null(name)) 
[17:29:21.273]                               next
[17:29:21.273]                             if (!grepl(pattern, name)) 
[17:29:21.273]                               next
[17:29:21.273]                             invokeRestart(restart)
[17:29:21.273]                             muffled <- TRUE
[17:29:21.273]                             break
[17:29:21.273]                           }
[17:29:21.273]                         }
[17:29:21.273]                       }
[17:29:21.273]                       invisible(muffled)
[17:29:21.273]                     }
[17:29:21.273]                     muffleCondition(cond, pattern = "^muffle")
[17:29:21.273]                   }
[17:29:21.273]                 }
[17:29:21.273]             }
[17:29:21.273]         }))
[17:29:21.273]     }, error = function(ex) {
[17:29:21.273]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:21.273]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:21.273]                 ...future.rng), started = ...future.startTime, 
[17:29:21.273]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:21.273]             version = "1.8"), class = "FutureResult")
[17:29:21.273]     }, finally = {
[17:29:21.273]         if (!identical(...future.workdir, getwd())) 
[17:29:21.273]             setwd(...future.workdir)
[17:29:21.273]         {
[17:29:21.273]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:21.273]                 ...future.oldOptions$nwarnings <- NULL
[17:29:21.273]             }
[17:29:21.273]             base::options(...future.oldOptions)
[17:29:21.273]             if (.Platform$OS.type == "windows") {
[17:29:21.273]                 old_names <- names(...future.oldEnvVars)
[17:29:21.273]                 envs <- base::Sys.getenv()
[17:29:21.273]                 names <- names(envs)
[17:29:21.273]                 common <- intersect(names, old_names)
[17:29:21.273]                 added <- setdiff(names, old_names)
[17:29:21.273]                 removed <- setdiff(old_names, names)
[17:29:21.273]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:21.273]                   envs[common]]
[17:29:21.273]                 NAMES <- toupper(changed)
[17:29:21.273]                 args <- list()
[17:29:21.273]                 for (kk in seq_along(NAMES)) {
[17:29:21.273]                   name <- changed[[kk]]
[17:29:21.273]                   NAME <- NAMES[[kk]]
[17:29:21.273]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:21.273]                     next
[17:29:21.273]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:21.273]                 }
[17:29:21.273]                 NAMES <- toupper(added)
[17:29:21.273]                 for (kk in seq_along(NAMES)) {
[17:29:21.273]                   name <- added[[kk]]
[17:29:21.273]                   NAME <- NAMES[[kk]]
[17:29:21.273]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:21.273]                     next
[17:29:21.273]                   args[[name]] <- ""
[17:29:21.273]                 }
[17:29:21.273]                 NAMES <- toupper(removed)
[17:29:21.273]                 for (kk in seq_along(NAMES)) {
[17:29:21.273]                   name <- removed[[kk]]
[17:29:21.273]                   NAME <- NAMES[[kk]]
[17:29:21.273]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:21.273]                     next
[17:29:21.273]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:21.273]                 }
[17:29:21.273]                 if (length(args) > 0) 
[17:29:21.273]                   base::do.call(base::Sys.setenv, args = args)
[17:29:21.273]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:21.273]             }
[17:29:21.273]             else {
[17:29:21.273]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:21.273]             }
[17:29:21.273]             {
[17:29:21.273]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:21.273]                   0L) {
[17:29:21.273]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:21.273]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:21.273]                   base::options(opts)
[17:29:21.273]                 }
[17:29:21.273]                 {
[17:29:21.273]                   {
[17:29:21.273]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:21.273]                     NULL
[17:29:21.273]                   }
[17:29:21.273]                   options(future.plan = NULL)
[17:29:21.273]                   if (is.na(NA_character_)) 
[17:29:21.273]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:21.273]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:21.273]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:21.273]                     .init = FALSE)
[17:29:21.273]                 }
[17:29:21.273]             }
[17:29:21.273]         }
[17:29:21.273]     })
[17:29:21.273]     if (TRUE) {
[17:29:21.273]         base::sink(type = "output", split = FALSE)
[17:29:21.273]         if (TRUE) {
[17:29:21.273]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:21.273]         }
[17:29:21.273]         else {
[17:29:21.273]             ...future.result["stdout"] <- base::list(NULL)
[17:29:21.273]         }
[17:29:21.273]         base::close(...future.stdout)
[17:29:21.273]         ...future.stdout <- NULL
[17:29:21.273]     }
[17:29:21.273]     ...future.result$conditions <- ...future.conditions
[17:29:21.273]     ...future.result$finished <- base::Sys.time()
[17:29:21.273]     ...future.result
[17:29:21.273] }
[17:29:21.282] MultisessionFuture started
[17:29:21.283] - Launch lazy future ... done
[17:29:21.283] run() for 'MultisessionFuture' ... done
[17:29:21.307] receiveMessageFromWorker() for ClusterFuture ...
[17:29:21.307] - Validating connection of MultisessionFuture
[17:29:21.308] - received message: FutureResult
[17:29:21.308] - Received FutureResult
[17:29:21.308] - Erased future from FutureRegistry
[17:29:21.308] result() for ClusterFuture ...
[17:29:21.309] - result already collected: FutureResult
[17:29:21.309] result() for ClusterFuture ... done
[17:29:21.309] signalConditions() ...
[17:29:21.309]  - include = 'immediateCondition'
[17:29:21.309]  - exclude = 
[17:29:21.309]  - resignal = FALSE
[17:29:21.310]  - Number of conditions: 1
[17:29:21.310] signalConditions() ... done
[17:29:21.310] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:21.310] A MultisessionFuture was resolved (and resolved itself)
[17:29:21.310] getGlobalsAndPackages() ...
[17:29:21.310] Searching for globals...
[17:29:21.311] - globals found: [2] 'list', 'stop'
[17:29:21.312] Searching for globals ... DONE
[17:29:21.312] Resolving globals: FALSE
[17:29:21.312] 
[17:29:21.312] 
[17:29:21.313] getGlobalsAndPackages() ... DONE
[17:29:21.313] run() for 'Future' ...
[17:29:21.313] - state: 'created'
[17:29:21.313] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:21.332] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:21.332] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:21.332]   - Field: 'node'
[17:29:21.333]   - Field: 'label'
[17:29:21.333]   - Field: 'local'
[17:29:21.333]   - Field: 'owner'
[17:29:21.334]   - Field: 'envir'
[17:29:21.334]   - Field: 'workers'
[17:29:21.334]   - Field: 'packages'
[17:29:21.334]   - Field: 'gc'
[17:29:21.335]   - Field: 'conditions'
[17:29:21.335]   - Field: 'persistent'
[17:29:21.335]   - Field: 'expr'
[17:29:21.335]   - Field: 'uuid'
[17:29:21.336]   - Field: 'seed'
[17:29:21.336]   - Field: 'version'
[17:29:21.336]   - Field: 'result'
[17:29:21.336]   - Field: 'asynchronous'
[17:29:21.337]   - Field: 'calls'
[17:29:21.337]   - Field: 'globals'
[17:29:21.337]   - Field: 'stdout'
[17:29:21.337]   - Field: 'earlySignal'
[17:29:21.338]   - Field: 'lazy'
[17:29:21.338]   - Field: 'state'
[17:29:21.338] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:21.338] - Launch lazy future ...
[17:29:21.339] Packages needed by the future expression (n = 0): <none>
[17:29:21.339] Packages needed by future strategies (n = 0): <none>
[17:29:21.340] {
[17:29:21.340]     {
[17:29:21.340]         {
[17:29:21.340]             ...future.startTime <- base::Sys.time()
[17:29:21.340]             {
[17:29:21.340]                 {
[17:29:21.340]                   {
[17:29:21.340]                     {
[17:29:21.340]                       base::local({
[17:29:21.340]                         has_future <- base::requireNamespace("future", 
[17:29:21.340]                           quietly = TRUE)
[17:29:21.340]                         if (has_future) {
[17:29:21.340]                           ns <- base::getNamespace("future")
[17:29:21.340]                           version <- ns[[".package"]][["version"]]
[17:29:21.340]                           if (is.null(version)) 
[17:29:21.340]                             version <- utils::packageVersion("future")
[17:29:21.340]                         }
[17:29:21.340]                         else {
[17:29:21.340]                           version <- NULL
[17:29:21.340]                         }
[17:29:21.340]                         if (!has_future || version < "1.8.0") {
[17:29:21.340]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:21.340]                             "", base::R.version$version.string), 
[17:29:21.340]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:21.340]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:21.340]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:21.340]                               "release", "version")], collapse = " "), 
[17:29:21.340]                             hostname = base::Sys.info()[["nodename"]])
[17:29:21.340]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:21.340]                             info)
[17:29:21.340]                           info <- base::paste(info, collapse = "; ")
[17:29:21.340]                           if (!has_future) {
[17:29:21.340]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:21.340]                               info)
[17:29:21.340]                           }
[17:29:21.340]                           else {
[17:29:21.340]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:21.340]                               info, version)
[17:29:21.340]                           }
[17:29:21.340]                           base::stop(msg)
[17:29:21.340]                         }
[17:29:21.340]                       })
[17:29:21.340]                     }
[17:29:21.340]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:21.340]                     base::options(mc.cores = 1L)
[17:29:21.340]                   }
[17:29:21.340]                   ...future.strategy.old <- future::plan("list")
[17:29:21.340]                   options(future.plan = NULL)
[17:29:21.340]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:21.340]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:21.340]                 }
[17:29:21.340]                 ...future.workdir <- getwd()
[17:29:21.340]             }
[17:29:21.340]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:21.340]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:21.340]         }
[17:29:21.340]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:21.340]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:21.340]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:21.340]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:21.340]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:21.340]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:21.340]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:21.340]             base::names(...future.oldOptions))
[17:29:21.340]     }
[17:29:21.340]     if (FALSE) {
[17:29:21.340]     }
[17:29:21.340]     else {
[17:29:21.340]         if (TRUE) {
[17:29:21.340]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:21.340]                 open = "w")
[17:29:21.340]         }
[17:29:21.340]         else {
[17:29:21.340]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:21.340]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:21.340]         }
[17:29:21.340]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:21.340]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:21.340]             base::sink(type = "output", split = FALSE)
[17:29:21.340]             base::close(...future.stdout)
[17:29:21.340]         }, add = TRUE)
[17:29:21.340]     }
[17:29:21.340]     ...future.frame <- base::sys.nframe()
[17:29:21.340]     ...future.conditions <- base::list()
[17:29:21.340]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:21.340]     if (FALSE) {
[17:29:21.340]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:21.340]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:21.340]     }
[17:29:21.340]     ...future.result <- base::tryCatch({
[17:29:21.340]         base::withCallingHandlers({
[17:29:21.340]             ...future.value <- base::withVisible(base::local({
[17:29:21.340]                 ...future.makeSendCondition <- base::local({
[17:29:21.340]                   sendCondition <- NULL
[17:29:21.340]                   function(frame = 1L) {
[17:29:21.340]                     if (is.function(sendCondition)) 
[17:29:21.340]                       return(sendCondition)
[17:29:21.340]                     ns <- getNamespace("parallel")
[17:29:21.340]                     if (exists("sendData", mode = "function", 
[17:29:21.340]                       envir = ns)) {
[17:29:21.340]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:21.340]                         envir = ns)
[17:29:21.340]                       envir <- sys.frame(frame)
[17:29:21.340]                       master <- NULL
[17:29:21.340]                       while (!identical(envir, .GlobalEnv) && 
[17:29:21.340]                         !identical(envir, emptyenv())) {
[17:29:21.340]                         if (exists("master", mode = "list", envir = envir, 
[17:29:21.340]                           inherits = FALSE)) {
[17:29:21.340]                           master <- get("master", mode = "list", 
[17:29:21.340]                             envir = envir, inherits = FALSE)
[17:29:21.340]                           if (inherits(master, c("SOCKnode", 
[17:29:21.340]                             "SOCK0node"))) {
[17:29:21.340]                             sendCondition <<- function(cond) {
[17:29:21.340]                               data <- list(type = "VALUE", value = cond, 
[17:29:21.340]                                 success = TRUE)
[17:29:21.340]                               parallel_sendData(master, data)
[17:29:21.340]                             }
[17:29:21.340]                             return(sendCondition)
[17:29:21.340]                           }
[17:29:21.340]                         }
[17:29:21.340]                         frame <- frame + 1L
[17:29:21.340]                         envir <- sys.frame(frame)
[17:29:21.340]                       }
[17:29:21.340]                     }
[17:29:21.340]                     sendCondition <<- function(cond) NULL
[17:29:21.340]                   }
[17:29:21.340]                 })
[17:29:21.340]                 withCallingHandlers({
[17:29:21.340]                   list(a = 1, b = 42L, c = stop("Nah!"))
[17:29:21.340]                 }, immediateCondition = function(cond) {
[17:29:21.340]                   sendCondition <- ...future.makeSendCondition()
[17:29:21.340]                   sendCondition(cond)
[17:29:21.340]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:21.340]                   {
[17:29:21.340]                     inherits <- base::inherits
[17:29:21.340]                     invokeRestart <- base::invokeRestart
[17:29:21.340]                     is.null <- base::is.null
[17:29:21.340]                     muffled <- FALSE
[17:29:21.340]                     if (inherits(cond, "message")) {
[17:29:21.340]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:21.340]                       if (muffled) 
[17:29:21.340]                         invokeRestart("muffleMessage")
[17:29:21.340]                     }
[17:29:21.340]                     else if (inherits(cond, "warning")) {
[17:29:21.340]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:21.340]                       if (muffled) 
[17:29:21.340]                         invokeRestart("muffleWarning")
[17:29:21.340]                     }
[17:29:21.340]                     else if (inherits(cond, "condition")) {
[17:29:21.340]                       if (!is.null(pattern)) {
[17:29:21.340]                         computeRestarts <- base::computeRestarts
[17:29:21.340]                         grepl <- base::grepl
[17:29:21.340]                         restarts <- computeRestarts(cond)
[17:29:21.340]                         for (restart in restarts) {
[17:29:21.340]                           name <- restart$name
[17:29:21.340]                           if (is.null(name)) 
[17:29:21.340]                             next
[17:29:21.340]                           if (!grepl(pattern, name)) 
[17:29:21.340]                             next
[17:29:21.340]                           invokeRestart(restart)
[17:29:21.340]                           muffled <- TRUE
[17:29:21.340]                           break
[17:29:21.340]                         }
[17:29:21.340]                       }
[17:29:21.340]                     }
[17:29:21.340]                     invisible(muffled)
[17:29:21.340]                   }
[17:29:21.340]                   muffleCondition(cond)
[17:29:21.340]                 })
[17:29:21.340]             }))
[17:29:21.340]             future::FutureResult(value = ...future.value$value, 
[17:29:21.340]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:21.340]                   ...future.rng), globalenv = if (FALSE) 
[17:29:21.340]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:21.340]                     ...future.globalenv.names))
[17:29:21.340]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:21.340]         }, condition = base::local({
[17:29:21.340]             c <- base::c
[17:29:21.340]             inherits <- base::inherits
[17:29:21.340]             invokeRestart <- base::invokeRestart
[17:29:21.340]             length <- base::length
[17:29:21.340]             list <- base::list
[17:29:21.340]             seq.int <- base::seq.int
[17:29:21.340]             signalCondition <- base::signalCondition
[17:29:21.340]             sys.calls <- base::sys.calls
[17:29:21.340]             `[[` <- base::`[[`
[17:29:21.340]             `+` <- base::`+`
[17:29:21.340]             `<<-` <- base::`<<-`
[17:29:21.340]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:21.340]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:21.340]                   3L)]
[17:29:21.340]             }
[17:29:21.340]             function(cond) {
[17:29:21.340]                 is_error <- inherits(cond, "error")
[17:29:21.340]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:21.340]                   NULL)
[17:29:21.340]                 if (is_error) {
[17:29:21.340]                   sessionInformation <- function() {
[17:29:21.340]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:21.340]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:21.340]                       search = base::search(), system = base::Sys.info())
[17:29:21.340]                   }
[17:29:21.340]                   ...future.conditions[[length(...future.conditions) + 
[17:29:21.340]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:21.340]                     cond$call), session = sessionInformation(), 
[17:29:21.340]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:21.340]                   signalCondition(cond)
[17:29:21.340]                 }
[17:29:21.340]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:21.340]                 "immediateCondition"))) {
[17:29:21.340]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:21.340]                   ...future.conditions[[length(...future.conditions) + 
[17:29:21.340]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:21.340]                   if (TRUE && !signal) {
[17:29:21.340]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:21.340]                     {
[17:29:21.340]                       inherits <- base::inherits
[17:29:21.340]                       invokeRestart <- base::invokeRestart
[17:29:21.340]                       is.null <- base::is.null
[17:29:21.340]                       muffled <- FALSE
[17:29:21.340]                       if (inherits(cond, "message")) {
[17:29:21.340]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:21.340]                         if (muffled) 
[17:29:21.340]                           invokeRestart("muffleMessage")
[17:29:21.340]                       }
[17:29:21.340]                       else if (inherits(cond, "warning")) {
[17:29:21.340]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:21.340]                         if (muffled) 
[17:29:21.340]                           invokeRestart("muffleWarning")
[17:29:21.340]                       }
[17:29:21.340]                       else if (inherits(cond, "condition")) {
[17:29:21.340]                         if (!is.null(pattern)) {
[17:29:21.340]                           computeRestarts <- base::computeRestarts
[17:29:21.340]                           grepl <- base::grepl
[17:29:21.340]                           restarts <- computeRestarts(cond)
[17:29:21.340]                           for (restart in restarts) {
[17:29:21.340]                             name <- restart$name
[17:29:21.340]                             if (is.null(name)) 
[17:29:21.340]                               next
[17:29:21.340]                             if (!grepl(pattern, name)) 
[17:29:21.340]                               next
[17:29:21.340]                             invokeRestart(restart)
[17:29:21.340]                             muffled <- TRUE
[17:29:21.340]                             break
[17:29:21.340]                           }
[17:29:21.340]                         }
[17:29:21.340]                       }
[17:29:21.340]                       invisible(muffled)
[17:29:21.340]                     }
[17:29:21.340]                     muffleCondition(cond, pattern = "^muffle")
[17:29:21.340]                   }
[17:29:21.340]                 }
[17:29:21.340]                 else {
[17:29:21.340]                   if (TRUE) {
[17:29:21.340]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:21.340]                     {
[17:29:21.340]                       inherits <- base::inherits
[17:29:21.340]                       invokeRestart <- base::invokeRestart
[17:29:21.340]                       is.null <- base::is.null
[17:29:21.340]                       muffled <- FALSE
[17:29:21.340]                       if (inherits(cond, "message")) {
[17:29:21.340]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:21.340]                         if (muffled) 
[17:29:21.340]                           invokeRestart("muffleMessage")
[17:29:21.340]                       }
[17:29:21.340]                       else if (inherits(cond, "warning")) {
[17:29:21.340]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:21.340]                         if (muffled) 
[17:29:21.340]                           invokeRestart("muffleWarning")
[17:29:21.340]                       }
[17:29:21.340]                       else if (inherits(cond, "condition")) {
[17:29:21.340]                         if (!is.null(pattern)) {
[17:29:21.340]                           computeRestarts <- base::computeRestarts
[17:29:21.340]                           grepl <- base::grepl
[17:29:21.340]                           restarts <- computeRestarts(cond)
[17:29:21.340]                           for (restart in restarts) {
[17:29:21.340]                             name <- restart$name
[17:29:21.340]                             if (is.null(name)) 
[17:29:21.340]                               next
[17:29:21.340]                             if (!grepl(pattern, name)) 
[17:29:21.340]                               next
[17:29:21.340]                             invokeRestart(restart)
[17:29:21.340]                             muffled <- TRUE
[17:29:21.340]                             break
[17:29:21.340]                           }
[17:29:21.340]                         }
[17:29:21.340]                       }
[17:29:21.340]                       invisible(muffled)
[17:29:21.340]                     }
[17:29:21.340]                     muffleCondition(cond, pattern = "^muffle")
[17:29:21.340]                   }
[17:29:21.340]                 }
[17:29:21.340]             }
[17:29:21.340]         }))
[17:29:21.340]     }, error = function(ex) {
[17:29:21.340]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:21.340]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:21.340]                 ...future.rng), started = ...future.startTime, 
[17:29:21.340]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:21.340]             version = "1.8"), class = "FutureResult")
[17:29:21.340]     }, finally = {
[17:29:21.340]         if (!identical(...future.workdir, getwd())) 
[17:29:21.340]             setwd(...future.workdir)
[17:29:21.340]         {
[17:29:21.340]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:21.340]                 ...future.oldOptions$nwarnings <- NULL
[17:29:21.340]             }
[17:29:21.340]             base::options(...future.oldOptions)
[17:29:21.340]             if (.Platform$OS.type == "windows") {
[17:29:21.340]                 old_names <- names(...future.oldEnvVars)
[17:29:21.340]                 envs <- base::Sys.getenv()
[17:29:21.340]                 names <- names(envs)
[17:29:21.340]                 common <- intersect(names, old_names)
[17:29:21.340]                 added <- setdiff(names, old_names)
[17:29:21.340]                 removed <- setdiff(old_names, names)
[17:29:21.340]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:21.340]                   envs[common]]
[17:29:21.340]                 NAMES <- toupper(changed)
[17:29:21.340]                 args <- list()
[17:29:21.340]                 for (kk in seq_along(NAMES)) {
[17:29:21.340]                   name <- changed[[kk]]
[17:29:21.340]                   NAME <- NAMES[[kk]]
[17:29:21.340]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:21.340]                     next
[17:29:21.340]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:21.340]                 }
[17:29:21.340]                 NAMES <- toupper(added)
[17:29:21.340]                 for (kk in seq_along(NAMES)) {
[17:29:21.340]                   name <- added[[kk]]
[17:29:21.340]                   NAME <- NAMES[[kk]]
[17:29:21.340]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:21.340]                     next
[17:29:21.340]                   args[[name]] <- ""
[17:29:21.340]                 }
[17:29:21.340]                 NAMES <- toupper(removed)
[17:29:21.340]                 for (kk in seq_along(NAMES)) {
[17:29:21.340]                   name <- removed[[kk]]
[17:29:21.340]                   NAME <- NAMES[[kk]]
[17:29:21.340]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:21.340]                     next
[17:29:21.340]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:21.340]                 }
[17:29:21.340]                 if (length(args) > 0) 
[17:29:21.340]                   base::do.call(base::Sys.setenv, args = args)
[17:29:21.340]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:21.340]             }
[17:29:21.340]             else {
[17:29:21.340]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:21.340]             }
[17:29:21.340]             {
[17:29:21.340]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:21.340]                   0L) {
[17:29:21.340]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:21.340]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:21.340]                   base::options(opts)
[17:29:21.340]                 }
[17:29:21.340]                 {
[17:29:21.340]                   {
[17:29:21.340]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:21.340]                     NULL
[17:29:21.340]                   }
[17:29:21.340]                   options(future.plan = NULL)
[17:29:21.340]                   if (is.na(NA_character_)) 
[17:29:21.340]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:21.340]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:21.340]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:21.340]                     .init = FALSE)
[17:29:21.340]                 }
[17:29:21.340]             }
[17:29:21.340]         }
[17:29:21.340]     })
[17:29:21.340]     if (TRUE) {
[17:29:21.340]         base::sink(type = "output", split = FALSE)
[17:29:21.340]         if (TRUE) {
[17:29:21.340]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:21.340]         }
[17:29:21.340]         else {
[17:29:21.340]             ...future.result["stdout"] <- base::list(NULL)
[17:29:21.340]         }
[17:29:21.340]         base::close(...future.stdout)
[17:29:21.340]         ...future.stdout <- NULL
[17:29:21.340]     }
[17:29:21.340]     ...future.result$conditions <- ...future.conditions
[17:29:21.340]     ...future.result$finished <- base::Sys.time()
[17:29:21.340]     ...future.result
[17:29:21.340] }
[17:29:21.348] MultisessionFuture started
[17:29:21.349] - Launch lazy future ... done
[17:29:21.349] run() for 'MultisessionFuture' ... done
[17:29:21.372] receiveMessageFromWorker() for ClusterFuture ...
[17:29:21.373] - Validating connection of MultisessionFuture
[17:29:21.374] - received message: FutureResult
[17:29:21.374] - Received FutureResult
[17:29:21.374] - Erased future from FutureRegistry
[17:29:21.374] result() for ClusterFuture ...
[17:29:21.374] - result already collected: FutureResult
[17:29:21.374] result() for ClusterFuture ... done
[17:29:21.375] signalConditions() ...
[17:29:21.375]  - include = 'immediateCondition'
[17:29:21.375]  - exclude = 
[17:29:21.375]  - resignal = FALSE
[17:29:21.375]  - Number of conditions: 1
[17:29:21.375] signalConditions() ... done
[17:29:21.376] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:21.376] A MultisessionFuture was resolved (and resolved itself)
- result = TRUE, recursive = 1 ... DONE
- result = TRUE, recursive = 2 ...
[17:29:21.376] getGlobalsAndPackages() ...
[17:29:21.376] Searching for globals...
[17:29:21.378] - globals found: [3] '{', 'Sys.sleep', 'list'
[17:29:21.378] Searching for globals ... DONE
[17:29:21.378] Resolving globals: FALSE
[17:29:21.379] 
[17:29:21.379] 
[17:29:21.380] getGlobalsAndPackages() ... DONE
[17:29:21.380] run() for 'Future' ...
[17:29:21.381] - state: 'created'
[17:29:21.381] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:21.400] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:21.401] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:21.401]   - Field: 'node'
[17:29:21.401]   - Field: 'label'
[17:29:21.401]   - Field: 'local'
[17:29:21.401]   - Field: 'owner'
[17:29:21.402]   - Field: 'envir'
[17:29:21.402]   - Field: 'workers'
[17:29:21.402]   - Field: 'packages'
[17:29:21.402]   - Field: 'gc'
[17:29:21.402]   - Field: 'conditions'
[17:29:21.403]   - Field: 'persistent'
[17:29:21.403]   - Field: 'expr'
[17:29:21.403]   - Field: 'uuid'
[17:29:21.404]   - Field: 'seed'
[17:29:21.404]   - Field: 'version'
[17:29:21.404]   - Field: 'result'
[17:29:21.405]   - Field: 'asynchronous'
[17:29:21.405]   - Field: 'calls'
[17:29:21.405]   - Field: 'globals'
[17:29:21.406]   - Field: 'stdout'
[17:29:21.406]   - Field: 'earlySignal'
[17:29:21.406]   - Field: 'lazy'
[17:29:21.406]   - Field: 'state'
[17:29:21.407] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:21.407] - Launch lazy future ...
[17:29:21.407] Packages needed by the future expression (n = 0): <none>
[17:29:21.407] Packages needed by future strategies (n = 0): <none>
[17:29:21.408] {
[17:29:21.408]     {
[17:29:21.408]         {
[17:29:21.408]             ...future.startTime <- base::Sys.time()
[17:29:21.408]             {
[17:29:21.408]                 {
[17:29:21.408]                   {
[17:29:21.408]                     {
[17:29:21.408]                       base::local({
[17:29:21.408]                         has_future <- base::requireNamespace("future", 
[17:29:21.408]                           quietly = TRUE)
[17:29:21.408]                         if (has_future) {
[17:29:21.408]                           ns <- base::getNamespace("future")
[17:29:21.408]                           version <- ns[[".package"]][["version"]]
[17:29:21.408]                           if (is.null(version)) 
[17:29:21.408]                             version <- utils::packageVersion("future")
[17:29:21.408]                         }
[17:29:21.408]                         else {
[17:29:21.408]                           version <- NULL
[17:29:21.408]                         }
[17:29:21.408]                         if (!has_future || version < "1.8.0") {
[17:29:21.408]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:21.408]                             "", base::R.version$version.string), 
[17:29:21.408]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:21.408]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:21.408]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:21.408]                               "release", "version")], collapse = " "), 
[17:29:21.408]                             hostname = base::Sys.info()[["nodename"]])
[17:29:21.408]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:21.408]                             info)
[17:29:21.408]                           info <- base::paste(info, collapse = "; ")
[17:29:21.408]                           if (!has_future) {
[17:29:21.408]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:21.408]                               info)
[17:29:21.408]                           }
[17:29:21.408]                           else {
[17:29:21.408]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:21.408]                               info, version)
[17:29:21.408]                           }
[17:29:21.408]                           base::stop(msg)
[17:29:21.408]                         }
[17:29:21.408]                       })
[17:29:21.408]                     }
[17:29:21.408]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:21.408]                     base::options(mc.cores = 1L)
[17:29:21.408]                   }
[17:29:21.408]                   ...future.strategy.old <- future::plan("list")
[17:29:21.408]                   options(future.plan = NULL)
[17:29:21.408]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:21.408]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:21.408]                 }
[17:29:21.408]                 ...future.workdir <- getwd()
[17:29:21.408]             }
[17:29:21.408]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:21.408]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:21.408]         }
[17:29:21.408]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:21.408]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:21.408]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:21.408]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:21.408]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:21.408]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:21.408]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:21.408]             base::names(...future.oldOptions))
[17:29:21.408]     }
[17:29:21.408]     if (FALSE) {
[17:29:21.408]     }
[17:29:21.408]     else {
[17:29:21.408]         if (TRUE) {
[17:29:21.408]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:21.408]                 open = "w")
[17:29:21.408]         }
[17:29:21.408]         else {
[17:29:21.408]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:21.408]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:21.408]         }
[17:29:21.408]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:21.408]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:21.408]             base::sink(type = "output", split = FALSE)
[17:29:21.408]             base::close(...future.stdout)
[17:29:21.408]         }, add = TRUE)
[17:29:21.408]     }
[17:29:21.408]     ...future.frame <- base::sys.nframe()
[17:29:21.408]     ...future.conditions <- base::list()
[17:29:21.408]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:21.408]     if (FALSE) {
[17:29:21.408]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:21.408]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:21.408]     }
[17:29:21.408]     ...future.result <- base::tryCatch({
[17:29:21.408]         base::withCallingHandlers({
[17:29:21.408]             ...future.value <- base::withVisible(base::local({
[17:29:21.408]                 ...future.makeSendCondition <- base::local({
[17:29:21.408]                   sendCondition <- NULL
[17:29:21.408]                   function(frame = 1L) {
[17:29:21.408]                     if (is.function(sendCondition)) 
[17:29:21.408]                       return(sendCondition)
[17:29:21.408]                     ns <- getNamespace("parallel")
[17:29:21.408]                     if (exists("sendData", mode = "function", 
[17:29:21.408]                       envir = ns)) {
[17:29:21.408]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:21.408]                         envir = ns)
[17:29:21.408]                       envir <- sys.frame(frame)
[17:29:21.408]                       master <- NULL
[17:29:21.408]                       while (!identical(envir, .GlobalEnv) && 
[17:29:21.408]                         !identical(envir, emptyenv())) {
[17:29:21.408]                         if (exists("master", mode = "list", envir = envir, 
[17:29:21.408]                           inherits = FALSE)) {
[17:29:21.408]                           master <- get("master", mode = "list", 
[17:29:21.408]                             envir = envir, inherits = FALSE)
[17:29:21.408]                           if (inherits(master, c("SOCKnode", 
[17:29:21.408]                             "SOCK0node"))) {
[17:29:21.408]                             sendCondition <<- function(cond) {
[17:29:21.408]                               data <- list(type = "VALUE", value = cond, 
[17:29:21.408]                                 success = TRUE)
[17:29:21.408]                               parallel_sendData(master, data)
[17:29:21.408]                             }
[17:29:21.408]                             return(sendCondition)
[17:29:21.408]                           }
[17:29:21.408]                         }
[17:29:21.408]                         frame <- frame + 1L
[17:29:21.408]                         envir <- sys.frame(frame)
[17:29:21.408]                       }
[17:29:21.408]                     }
[17:29:21.408]                     sendCondition <<- function(cond) NULL
[17:29:21.408]                   }
[17:29:21.408]                 })
[17:29:21.408]                 withCallingHandlers({
[17:29:21.408]                   {
[17:29:21.408]                     Sys.sleep(0.5)
[17:29:21.408]                     list(a = 1, b = 42L)
[17:29:21.408]                   }
[17:29:21.408]                 }, immediateCondition = function(cond) {
[17:29:21.408]                   sendCondition <- ...future.makeSendCondition()
[17:29:21.408]                   sendCondition(cond)
[17:29:21.408]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:21.408]                   {
[17:29:21.408]                     inherits <- base::inherits
[17:29:21.408]                     invokeRestart <- base::invokeRestart
[17:29:21.408]                     is.null <- base::is.null
[17:29:21.408]                     muffled <- FALSE
[17:29:21.408]                     if (inherits(cond, "message")) {
[17:29:21.408]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:21.408]                       if (muffled) 
[17:29:21.408]                         invokeRestart("muffleMessage")
[17:29:21.408]                     }
[17:29:21.408]                     else if (inherits(cond, "warning")) {
[17:29:21.408]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:21.408]                       if (muffled) 
[17:29:21.408]                         invokeRestart("muffleWarning")
[17:29:21.408]                     }
[17:29:21.408]                     else if (inherits(cond, "condition")) {
[17:29:21.408]                       if (!is.null(pattern)) {
[17:29:21.408]                         computeRestarts <- base::computeRestarts
[17:29:21.408]                         grepl <- base::grepl
[17:29:21.408]                         restarts <- computeRestarts(cond)
[17:29:21.408]                         for (restart in restarts) {
[17:29:21.408]                           name <- restart$name
[17:29:21.408]                           if (is.null(name)) 
[17:29:21.408]                             next
[17:29:21.408]                           if (!grepl(pattern, name)) 
[17:29:21.408]                             next
[17:29:21.408]                           invokeRestart(restart)
[17:29:21.408]                           muffled <- TRUE
[17:29:21.408]                           break
[17:29:21.408]                         }
[17:29:21.408]                       }
[17:29:21.408]                     }
[17:29:21.408]                     invisible(muffled)
[17:29:21.408]                   }
[17:29:21.408]                   muffleCondition(cond)
[17:29:21.408]                 })
[17:29:21.408]             }))
[17:29:21.408]             future::FutureResult(value = ...future.value$value, 
[17:29:21.408]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:21.408]                   ...future.rng), globalenv = if (FALSE) 
[17:29:21.408]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:21.408]                     ...future.globalenv.names))
[17:29:21.408]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:21.408]         }, condition = base::local({
[17:29:21.408]             c <- base::c
[17:29:21.408]             inherits <- base::inherits
[17:29:21.408]             invokeRestart <- base::invokeRestart
[17:29:21.408]             length <- base::length
[17:29:21.408]             list <- base::list
[17:29:21.408]             seq.int <- base::seq.int
[17:29:21.408]             signalCondition <- base::signalCondition
[17:29:21.408]             sys.calls <- base::sys.calls
[17:29:21.408]             `[[` <- base::`[[`
[17:29:21.408]             `+` <- base::`+`
[17:29:21.408]             `<<-` <- base::`<<-`
[17:29:21.408]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:21.408]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:21.408]                   3L)]
[17:29:21.408]             }
[17:29:21.408]             function(cond) {
[17:29:21.408]                 is_error <- inherits(cond, "error")
[17:29:21.408]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:21.408]                   NULL)
[17:29:21.408]                 if (is_error) {
[17:29:21.408]                   sessionInformation <- function() {
[17:29:21.408]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:21.408]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:21.408]                       search = base::search(), system = base::Sys.info())
[17:29:21.408]                   }
[17:29:21.408]                   ...future.conditions[[length(...future.conditions) + 
[17:29:21.408]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:21.408]                     cond$call), session = sessionInformation(), 
[17:29:21.408]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:21.408]                   signalCondition(cond)
[17:29:21.408]                 }
[17:29:21.408]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:21.408]                 "immediateCondition"))) {
[17:29:21.408]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:21.408]                   ...future.conditions[[length(...future.conditions) + 
[17:29:21.408]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:21.408]                   if (TRUE && !signal) {
[17:29:21.408]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:21.408]                     {
[17:29:21.408]                       inherits <- base::inherits
[17:29:21.408]                       invokeRestart <- base::invokeRestart
[17:29:21.408]                       is.null <- base::is.null
[17:29:21.408]                       muffled <- FALSE
[17:29:21.408]                       if (inherits(cond, "message")) {
[17:29:21.408]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:21.408]                         if (muffled) 
[17:29:21.408]                           invokeRestart("muffleMessage")
[17:29:21.408]                       }
[17:29:21.408]                       else if (inherits(cond, "warning")) {
[17:29:21.408]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:21.408]                         if (muffled) 
[17:29:21.408]                           invokeRestart("muffleWarning")
[17:29:21.408]                       }
[17:29:21.408]                       else if (inherits(cond, "condition")) {
[17:29:21.408]                         if (!is.null(pattern)) {
[17:29:21.408]                           computeRestarts <- base::computeRestarts
[17:29:21.408]                           grepl <- base::grepl
[17:29:21.408]                           restarts <- computeRestarts(cond)
[17:29:21.408]                           for (restart in restarts) {
[17:29:21.408]                             name <- restart$name
[17:29:21.408]                             if (is.null(name)) 
[17:29:21.408]                               next
[17:29:21.408]                             if (!grepl(pattern, name)) 
[17:29:21.408]                               next
[17:29:21.408]                             invokeRestart(restart)
[17:29:21.408]                             muffled <- TRUE
[17:29:21.408]                             break
[17:29:21.408]                           }
[17:29:21.408]                         }
[17:29:21.408]                       }
[17:29:21.408]                       invisible(muffled)
[17:29:21.408]                     }
[17:29:21.408]                     muffleCondition(cond, pattern = "^muffle")
[17:29:21.408]                   }
[17:29:21.408]                 }
[17:29:21.408]                 else {
[17:29:21.408]                   if (TRUE) {
[17:29:21.408]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:21.408]                     {
[17:29:21.408]                       inherits <- base::inherits
[17:29:21.408]                       invokeRestart <- base::invokeRestart
[17:29:21.408]                       is.null <- base::is.null
[17:29:21.408]                       muffled <- FALSE
[17:29:21.408]                       if (inherits(cond, "message")) {
[17:29:21.408]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:21.408]                         if (muffled) 
[17:29:21.408]                           invokeRestart("muffleMessage")
[17:29:21.408]                       }
[17:29:21.408]                       else if (inherits(cond, "warning")) {
[17:29:21.408]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:21.408]                         if (muffled) 
[17:29:21.408]                           invokeRestart("muffleWarning")
[17:29:21.408]                       }
[17:29:21.408]                       else if (inherits(cond, "condition")) {
[17:29:21.408]                         if (!is.null(pattern)) {
[17:29:21.408]                           computeRestarts <- base::computeRestarts
[17:29:21.408]                           grepl <- base::grepl
[17:29:21.408]                           restarts <- computeRestarts(cond)
[17:29:21.408]                           for (restart in restarts) {
[17:29:21.408]                             name <- restart$name
[17:29:21.408]                             if (is.null(name)) 
[17:29:21.408]                               next
[17:29:21.408]                             if (!grepl(pattern, name)) 
[17:29:21.408]                               next
[17:29:21.408]                             invokeRestart(restart)
[17:29:21.408]                             muffled <- TRUE
[17:29:21.408]                             break
[17:29:21.408]                           }
[17:29:21.408]                         }
[17:29:21.408]                       }
[17:29:21.408]                       invisible(muffled)
[17:29:21.408]                     }
[17:29:21.408]                     muffleCondition(cond, pattern = "^muffle")
[17:29:21.408]                   }
[17:29:21.408]                 }
[17:29:21.408]             }
[17:29:21.408]         }))
[17:29:21.408]     }, error = function(ex) {
[17:29:21.408]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:21.408]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:21.408]                 ...future.rng), started = ...future.startTime, 
[17:29:21.408]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:21.408]             version = "1.8"), class = "FutureResult")
[17:29:21.408]     }, finally = {
[17:29:21.408]         if (!identical(...future.workdir, getwd())) 
[17:29:21.408]             setwd(...future.workdir)
[17:29:21.408]         {
[17:29:21.408]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:21.408]                 ...future.oldOptions$nwarnings <- NULL
[17:29:21.408]             }
[17:29:21.408]             base::options(...future.oldOptions)
[17:29:21.408]             if (.Platform$OS.type == "windows") {
[17:29:21.408]                 old_names <- names(...future.oldEnvVars)
[17:29:21.408]                 envs <- base::Sys.getenv()
[17:29:21.408]                 names <- names(envs)
[17:29:21.408]                 common <- intersect(names, old_names)
[17:29:21.408]                 added <- setdiff(names, old_names)
[17:29:21.408]                 removed <- setdiff(old_names, names)
[17:29:21.408]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:21.408]                   envs[common]]
[17:29:21.408]                 NAMES <- toupper(changed)
[17:29:21.408]                 args <- list()
[17:29:21.408]                 for (kk in seq_along(NAMES)) {
[17:29:21.408]                   name <- changed[[kk]]
[17:29:21.408]                   NAME <- NAMES[[kk]]
[17:29:21.408]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:21.408]                     next
[17:29:21.408]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:21.408]                 }
[17:29:21.408]                 NAMES <- toupper(added)
[17:29:21.408]                 for (kk in seq_along(NAMES)) {
[17:29:21.408]                   name <- added[[kk]]
[17:29:21.408]                   NAME <- NAMES[[kk]]
[17:29:21.408]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:21.408]                     next
[17:29:21.408]                   args[[name]] <- ""
[17:29:21.408]                 }
[17:29:21.408]                 NAMES <- toupper(removed)
[17:29:21.408]                 for (kk in seq_along(NAMES)) {
[17:29:21.408]                   name <- removed[[kk]]
[17:29:21.408]                   NAME <- NAMES[[kk]]
[17:29:21.408]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:21.408]                     next
[17:29:21.408]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:21.408]                 }
[17:29:21.408]                 if (length(args) > 0) 
[17:29:21.408]                   base::do.call(base::Sys.setenv, args = args)
[17:29:21.408]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:21.408]             }
[17:29:21.408]             else {
[17:29:21.408]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:21.408]             }
[17:29:21.408]             {
[17:29:21.408]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:21.408]                   0L) {
[17:29:21.408]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:21.408]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:21.408]                   base::options(opts)
[17:29:21.408]                 }
[17:29:21.408]                 {
[17:29:21.408]                   {
[17:29:21.408]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:21.408]                     NULL
[17:29:21.408]                   }
[17:29:21.408]                   options(future.plan = NULL)
[17:29:21.408]                   if (is.na(NA_character_)) 
[17:29:21.408]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:21.408]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:21.408]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:21.408]                     .init = FALSE)
[17:29:21.408]                 }
[17:29:21.408]             }
[17:29:21.408]         }
[17:29:21.408]     })
[17:29:21.408]     if (TRUE) {
[17:29:21.408]         base::sink(type = "output", split = FALSE)
[17:29:21.408]         if (TRUE) {
[17:29:21.408]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:21.408]         }
[17:29:21.408]         else {
[17:29:21.408]             ...future.result["stdout"] <- base::list(NULL)
[17:29:21.408]         }
[17:29:21.408]         base::close(...future.stdout)
[17:29:21.408]         ...future.stdout <- NULL
[17:29:21.408]     }
[17:29:21.408]     ...future.result$conditions <- ...future.conditions
[17:29:21.408]     ...future.result$finished <- base::Sys.time()
[17:29:21.408]     ...future.result
[17:29:21.408] }
[17:29:21.414] MultisessionFuture started
[17:29:21.415] - Launch lazy future ... done
[17:29:21.415] run() for 'MultisessionFuture' ... done
[17:29:21.950] receiveMessageFromWorker() for ClusterFuture ...
[17:29:21.951] - Validating connection of MultisessionFuture
[17:29:21.952] - received message: FutureResult
[17:29:21.952] - Received FutureResult
[17:29:21.952] - Erased future from FutureRegistry
[17:29:21.953] result() for ClusterFuture ...
[17:29:21.953] - result already collected: FutureResult
[17:29:21.953] result() for ClusterFuture ... done
[17:29:21.954] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:21.954] resolve() on list ...
[17:29:21.954]  recursive: 1
[17:29:21.954]  length: 2
[17:29:21.955]  elements: 'a', 'b'
[17:29:21.955]  length: 1 (resolved future 1)
[17:29:21.955]  length: 0 (resolved future 2)
[17:29:21.956] resolve() on list ... DONE
[17:29:21.956] A MultisessionFuture was resolved (and resolved itself)
[17:29:21.957] getGlobalsAndPackages() ...
[17:29:21.957] Searching for globals...
[17:29:21.961] - globals found: [3] '{', 'Sys.sleep', 'list'
[17:29:21.961] Searching for globals ... DONE
[17:29:21.962] Resolving globals: FALSE
[17:29:21.963] 
[17:29:21.963] 
[17:29:21.963] getGlobalsAndPackages() ... DONE
[17:29:21.964] run() for 'Future' ...
[17:29:21.964] - state: 'created'
[17:29:21.965] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:21.989] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:21.989] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:21.990]   - Field: 'node'
[17:29:21.990]   - Field: 'label'
[17:29:21.990]   - Field: 'local'
[17:29:21.991]   - Field: 'owner'
[17:29:21.991]   - Field: 'envir'
[17:29:21.992]   - Field: 'workers'
[17:29:21.992]   - Field: 'packages'
[17:29:21.992]   - Field: 'gc'
[17:29:21.993]   - Field: 'conditions'
[17:29:21.993]   - Field: 'persistent'
[17:29:21.994]   - Field: 'expr'
[17:29:21.994]   - Field: 'uuid'
[17:29:21.994]   - Field: 'seed'
[17:29:21.995]   - Field: 'version'
[17:29:21.995]   - Field: 'result'
[17:29:21.996]   - Field: 'asynchronous'
[17:29:21.996]   - Field: 'calls'
[17:29:21.996]   - Field: 'globals'
[17:29:21.997]   - Field: 'stdout'
[17:29:21.997]   - Field: 'earlySignal'
[17:29:21.998]   - Field: 'lazy'
[17:29:21.998]   - Field: 'state'
[17:29:21.998] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:21.999] - Launch lazy future ...
[17:29:22.000] Packages needed by the future expression (n = 0): <none>
[17:29:22.000] Packages needed by future strategies (n = 0): <none>
[17:29:22.001] {
[17:29:22.001]     {
[17:29:22.001]         {
[17:29:22.001]             ...future.startTime <- base::Sys.time()
[17:29:22.001]             {
[17:29:22.001]                 {
[17:29:22.001]                   {
[17:29:22.001]                     {
[17:29:22.001]                       base::local({
[17:29:22.001]                         has_future <- base::requireNamespace("future", 
[17:29:22.001]                           quietly = TRUE)
[17:29:22.001]                         if (has_future) {
[17:29:22.001]                           ns <- base::getNamespace("future")
[17:29:22.001]                           version <- ns[[".package"]][["version"]]
[17:29:22.001]                           if (is.null(version)) 
[17:29:22.001]                             version <- utils::packageVersion("future")
[17:29:22.001]                         }
[17:29:22.001]                         else {
[17:29:22.001]                           version <- NULL
[17:29:22.001]                         }
[17:29:22.001]                         if (!has_future || version < "1.8.0") {
[17:29:22.001]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:22.001]                             "", base::R.version$version.string), 
[17:29:22.001]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:22.001]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:22.001]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:22.001]                               "release", "version")], collapse = " "), 
[17:29:22.001]                             hostname = base::Sys.info()[["nodename"]])
[17:29:22.001]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:22.001]                             info)
[17:29:22.001]                           info <- base::paste(info, collapse = "; ")
[17:29:22.001]                           if (!has_future) {
[17:29:22.001]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:22.001]                               info)
[17:29:22.001]                           }
[17:29:22.001]                           else {
[17:29:22.001]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:22.001]                               info, version)
[17:29:22.001]                           }
[17:29:22.001]                           base::stop(msg)
[17:29:22.001]                         }
[17:29:22.001]                       })
[17:29:22.001]                     }
[17:29:22.001]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:22.001]                     base::options(mc.cores = 1L)
[17:29:22.001]                   }
[17:29:22.001]                   ...future.strategy.old <- future::plan("list")
[17:29:22.001]                   options(future.plan = NULL)
[17:29:22.001]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:22.001]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:22.001]                 }
[17:29:22.001]                 ...future.workdir <- getwd()
[17:29:22.001]             }
[17:29:22.001]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:22.001]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:22.001]         }
[17:29:22.001]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:22.001]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:22.001]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:22.001]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:22.001]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:22.001]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:22.001]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:22.001]             base::names(...future.oldOptions))
[17:29:22.001]     }
[17:29:22.001]     if (FALSE) {
[17:29:22.001]     }
[17:29:22.001]     else {
[17:29:22.001]         if (TRUE) {
[17:29:22.001]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:22.001]                 open = "w")
[17:29:22.001]         }
[17:29:22.001]         else {
[17:29:22.001]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:22.001]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:22.001]         }
[17:29:22.001]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:22.001]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:22.001]             base::sink(type = "output", split = FALSE)
[17:29:22.001]             base::close(...future.stdout)
[17:29:22.001]         }, add = TRUE)
[17:29:22.001]     }
[17:29:22.001]     ...future.frame <- base::sys.nframe()
[17:29:22.001]     ...future.conditions <- base::list()
[17:29:22.001]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:22.001]     if (FALSE) {
[17:29:22.001]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:22.001]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:22.001]     }
[17:29:22.001]     ...future.result <- base::tryCatch({
[17:29:22.001]         base::withCallingHandlers({
[17:29:22.001]             ...future.value <- base::withVisible(base::local({
[17:29:22.001]                 ...future.makeSendCondition <- base::local({
[17:29:22.001]                   sendCondition <- NULL
[17:29:22.001]                   function(frame = 1L) {
[17:29:22.001]                     if (is.function(sendCondition)) 
[17:29:22.001]                       return(sendCondition)
[17:29:22.001]                     ns <- getNamespace("parallel")
[17:29:22.001]                     if (exists("sendData", mode = "function", 
[17:29:22.001]                       envir = ns)) {
[17:29:22.001]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:22.001]                         envir = ns)
[17:29:22.001]                       envir <- sys.frame(frame)
[17:29:22.001]                       master <- NULL
[17:29:22.001]                       while (!identical(envir, .GlobalEnv) && 
[17:29:22.001]                         !identical(envir, emptyenv())) {
[17:29:22.001]                         if (exists("master", mode = "list", envir = envir, 
[17:29:22.001]                           inherits = FALSE)) {
[17:29:22.001]                           master <- get("master", mode = "list", 
[17:29:22.001]                             envir = envir, inherits = FALSE)
[17:29:22.001]                           if (inherits(master, c("SOCKnode", 
[17:29:22.001]                             "SOCK0node"))) {
[17:29:22.001]                             sendCondition <<- function(cond) {
[17:29:22.001]                               data <- list(type = "VALUE", value = cond, 
[17:29:22.001]                                 success = TRUE)
[17:29:22.001]                               parallel_sendData(master, data)
[17:29:22.001]                             }
[17:29:22.001]                             return(sendCondition)
[17:29:22.001]                           }
[17:29:22.001]                         }
[17:29:22.001]                         frame <- frame + 1L
[17:29:22.001]                         envir <- sys.frame(frame)
[17:29:22.001]                       }
[17:29:22.001]                     }
[17:29:22.001]                     sendCondition <<- function(cond) NULL
[17:29:22.001]                   }
[17:29:22.001]                 })
[17:29:22.001]                 withCallingHandlers({
[17:29:22.001]                   {
[17:29:22.001]                     Sys.sleep(0.5)
[17:29:22.001]                     list(a = 1, b = 42L)
[17:29:22.001]                   }
[17:29:22.001]                 }, immediateCondition = function(cond) {
[17:29:22.001]                   sendCondition <- ...future.makeSendCondition()
[17:29:22.001]                   sendCondition(cond)
[17:29:22.001]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:22.001]                   {
[17:29:22.001]                     inherits <- base::inherits
[17:29:22.001]                     invokeRestart <- base::invokeRestart
[17:29:22.001]                     is.null <- base::is.null
[17:29:22.001]                     muffled <- FALSE
[17:29:22.001]                     if (inherits(cond, "message")) {
[17:29:22.001]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:22.001]                       if (muffled) 
[17:29:22.001]                         invokeRestart("muffleMessage")
[17:29:22.001]                     }
[17:29:22.001]                     else if (inherits(cond, "warning")) {
[17:29:22.001]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:22.001]                       if (muffled) 
[17:29:22.001]                         invokeRestart("muffleWarning")
[17:29:22.001]                     }
[17:29:22.001]                     else if (inherits(cond, "condition")) {
[17:29:22.001]                       if (!is.null(pattern)) {
[17:29:22.001]                         computeRestarts <- base::computeRestarts
[17:29:22.001]                         grepl <- base::grepl
[17:29:22.001]                         restarts <- computeRestarts(cond)
[17:29:22.001]                         for (restart in restarts) {
[17:29:22.001]                           name <- restart$name
[17:29:22.001]                           if (is.null(name)) 
[17:29:22.001]                             next
[17:29:22.001]                           if (!grepl(pattern, name)) 
[17:29:22.001]                             next
[17:29:22.001]                           invokeRestart(restart)
[17:29:22.001]                           muffled <- TRUE
[17:29:22.001]                           break
[17:29:22.001]                         }
[17:29:22.001]                       }
[17:29:22.001]                     }
[17:29:22.001]                     invisible(muffled)
[17:29:22.001]                   }
[17:29:22.001]                   muffleCondition(cond)
[17:29:22.001]                 })
[17:29:22.001]             }))
[17:29:22.001]             future::FutureResult(value = ...future.value$value, 
[17:29:22.001]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:22.001]                   ...future.rng), globalenv = if (FALSE) 
[17:29:22.001]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:22.001]                     ...future.globalenv.names))
[17:29:22.001]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:22.001]         }, condition = base::local({
[17:29:22.001]             c <- base::c
[17:29:22.001]             inherits <- base::inherits
[17:29:22.001]             invokeRestart <- base::invokeRestart
[17:29:22.001]             length <- base::length
[17:29:22.001]             list <- base::list
[17:29:22.001]             seq.int <- base::seq.int
[17:29:22.001]             signalCondition <- base::signalCondition
[17:29:22.001]             sys.calls <- base::sys.calls
[17:29:22.001]             `[[` <- base::`[[`
[17:29:22.001]             `+` <- base::`+`
[17:29:22.001]             `<<-` <- base::`<<-`
[17:29:22.001]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:22.001]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:22.001]                   3L)]
[17:29:22.001]             }
[17:29:22.001]             function(cond) {
[17:29:22.001]                 is_error <- inherits(cond, "error")
[17:29:22.001]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:22.001]                   NULL)
[17:29:22.001]                 if (is_error) {
[17:29:22.001]                   sessionInformation <- function() {
[17:29:22.001]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:22.001]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:22.001]                       search = base::search(), system = base::Sys.info())
[17:29:22.001]                   }
[17:29:22.001]                   ...future.conditions[[length(...future.conditions) + 
[17:29:22.001]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:22.001]                     cond$call), session = sessionInformation(), 
[17:29:22.001]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:22.001]                   signalCondition(cond)
[17:29:22.001]                 }
[17:29:22.001]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:22.001]                 "immediateCondition"))) {
[17:29:22.001]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:22.001]                   ...future.conditions[[length(...future.conditions) + 
[17:29:22.001]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:22.001]                   if (TRUE && !signal) {
[17:29:22.001]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:22.001]                     {
[17:29:22.001]                       inherits <- base::inherits
[17:29:22.001]                       invokeRestart <- base::invokeRestart
[17:29:22.001]                       is.null <- base::is.null
[17:29:22.001]                       muffled <- FALSE
[17:29:22.001]                       if (inherits(cond, "message")) {
[17:29:22.001]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:22.001]                         if (muffled) 
[17:29:22.001]                           invokeRestart("muffleMessage")
[17:29:22.001]                       }
[17:29:22.001]                       else if (inherits(cond, "warning")) {
[17:29:22.001]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:22.001]                         if (muffled) 
[17:29:22.001]                           invokeRestart("muffleWarning")
[17:29:22.001]                       }
[17:29:22.001]                       else if (inherits(cond, "condition")) {
[17:29:22.001]                         if (!is.null(pattern)) {
[17:29:22.001]                           computeRestarts <- base::computeRestarts
[17:29:22.001]                           grepl <- base::grepl
[17:29:22.001]                           restarts <- computeRestarts(cond)
[17:29:22.001]                           for (restart in restarts) {
[17:29:22.001]                             name <- restart$name
[17:29:22.001]                             if (is.null(name)) 
[17:29:22.001]                               next
[17:29:22.001]                             if (!grepl(pattern, name)) 
[17:29:22.001]                               next
[17:29:22.001]                             invokeRestart(restart)
[17:29:22.001]                             muffled <- TRUE
[17:29:22.001]                             break
[17:29:22.001]                           }
[17:29:22.001]                         }
[17:29:22.001]                       }
[17:29:22.001]                       invisible(muffled)
[17:29:22.001]                     }
[17:29:22.001]                     muffleCondition(cond, pattern = "^muffle")
[17:29:22.001]                   }
[17:29:22.001]                 }
[17:29:22.001]                 else {
[17:29:22.001]                   if (TRUE) {
[17:29:22.001]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:22.001]                     {
[17:29:22.001]                       inherits <- base::inherits
[17:29:22.001]                       invokeRestart <- base::invokeRestart
[17:29:22.001]                       is.null <- base::is.null
[17:29:22.001]                       muffled <- FALSE
[17:29:22.001]                       if (inherits(cond, "message")) {
[17:29:22.001]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:22.001]                         if (muffled) 
[17:29:22.001]                           invokeRestart("muffleMessage")
[17:29:22.001]                       }
[17:29:22.001]                       else if (inherits(cond, "warning")) {
[17:29:22.001]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:22.001]                         if (muffled) 
[17:29:22.001]                           invokeRestart("muffleWarning")
[17:29:22.001]                       }
[17:29:22.001]                       else if (inherits(cond, "condition")) {
[17:29:22.001]                         if (!is.null(pattern)) {
[17:29:22.001]                           computeRestarts <- base::computeRestarts
[17:29:22.001]                           grepl <- base::grepl
[17:29:22.001]                           restarts <- computeRestarts(cond)
[17:29:22.001]                           for (restart in restarts) {
[17:29:22.001]                             name <- restart$name
[17:29:22.001]                             if (is.null(name)) 
[17:29:22.001]                               next
[17:29:22.001]                             if (!grepl(pattern, name)) 
[17:29:22.001]                               next
[17:29:22.001]                             invokeRestart(restart)
[17:29:22.001]                             muffled <- TRUE
[17:29:22.001]                             break
[17:29:22.001]                           }
[17:29:22.001]                         }
[17:29:22.001]                       }
[17:29:22.001]                       invisible(muffled)
[17:29:22.001]                     }
[17:29:22.001]                     muffleCondition(cond, pattern = "^muffle")
[17:29:22.001]                   }
[17:29:22.001]                 }
[17:29:22.001]             }
[17:29:22.001]         }))
[17:29:22.001]     }, error = function(ex) {
[17:29:22.001]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:22.001]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:22.001]                 ...future.rng), started = ...future.startTime, 
[17:29:22.001]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:22.001]             version = "1.8"), class = "FutureResult")
[17:29:22.001]     }, finally = {
[17:29:22.001]         if (!identical(...future.workdir, getwd())) 
[17:29:22.001]             setwd(...future.workdir)
[17:29:22.001]         {
[17:29:22.001]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:22.001]                 ...future.oldOptions$nwarnings <- NULL
[17:29:22.001]             }
[17:29:22.001]             base::options(...future.oldOptions)
[17:29:22.001]             if (.Platform$OS.type == "windows") {
[17:29:22.001]                 old_names <- names(...future.oldEnvVars)
[17:29:22.001]                 envs <- base::Sys.getenv()
[17:29:22.001]                 names <- names(envs)
[17:29:22.001]                 common <- intersect(names, old_names)
[17:29:22.001]                 added <- setdiff(names, old_names)
[17:29:22.001]                 removed <- setdiff(old_names, names)
[17:29:22.001]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:22.001]                   envs[common]]
[17:29:22.001]                 NAMES <- toupper(changed)
[17:29:22.001]                 args <- list()
[17:29:22.001]                 for (kk in seq_along(NAMES)) {
[17:29:22.001]                   name <- changed[[kk]]
[17:29:22.001]                   NAME <- NAMES[[kk]]
[17:29:22.001]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:22.001]                     next
[17:29:22.001]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:22.001]                 }
[17:29:22.001]                 NAMES <- toupper(added)
[17:29:22.001]                 for (kk in seq_along(NAMES)) {
[17:29:22.001]                   name <- added[[kk]]
[17:29:22.001]                   NAME <- NAMES[[kk]]
[17:29:22.001]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:22.001]                     next
[17:29:22.001]                   args[[name]] <- ""
[17:29:22.001]                 }
[17:29:22.001]                 NAMES <- toupper(removed)
[17:29:22.001]                 for (kk in seq_along(NAMES)) {
[17:29:22.001]                   name <- removed[[kk]]
[17:29:22.001]                   NAME <- NAMES[[kk]]
[17:29:22.001]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:22.001]                     next
[17:29:22.001]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:22.001]                 }
[17:29:22.001]                 if (length(args) > 0) 
[17:29:22.001]                   base::do.call(base::Sys.setenv, args = args)
[17:29:22.001]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:22.001]             }
[17:29:22.001]             else {
[17:29:22.001]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:22.001]             }
[17:29:22.001]             {
[17:29:22.001]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:22.001]                   0L) {
[17:29:22.001]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:22.001]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:22.001]                   base::options(opts)
[17:29:22.001]                 }
[17:29:22.001]                 {
[17:29:22.001]                   {
[17:29:22.001]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:22.001]                     NULL
[17:29:22.001]                   }
[17:29:22.001]                   options(future.plan = NULL)
[17:29:22.001]                   if (is.na(NA_character_)) 
[17:29:22.001]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:22.001]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:22.001]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:22.001]                     .init = FALSE)
[17:29:22.001]                 }
[17:29:22.001]             }
[17:29:22.001]         }
[17:29:22.001]     })
[17:29:22.001]     if (TRUE) {
[17:29:22.001]         base::sink(type = "output", split = FALSE)
[17:29:22.001]         if (TRUE) {
[17:29:22.001]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:22.001]         }
[17:29:22.001]         else {
[17:29:22.001]             ...future.result["stdout"] <- base::list(NULL)
[17:29:22.001]         }
[17:29:22.001]         base::close(...future.stdout)
[17:29:22.001]         ...future.stdout <- NULL
[17:29:22.001]     }
[17:29:22.001]     ...future.result$conditions <- ...future.conditions
[17:29:22.001]     ...future.result$finished <- base::Sys.time()
[17:29:22.001]     ...future.result
[17:29:22.001] }
[17:29:22.014] MultisessionFuture started
[17:29:22.014] - Launch lazy future ... done
[17:29:22.014] run() for 'MultisessionFuture' ... done
[17:29:22.535] receiveMessageFromWorker() for ClusterFuture ...
[17:29:22.536] - Validating connection of MultisessionFuture
[17:29:22.536] - received message: FutureResult
[17:29:22.536] - Received FutureResult
[17:29:22.537] - Erased future from FutureRegistry
[17:29:22.537] result() for ClusterFuture ...
[17:29:22.537] - result already collected: FutureResult
[17:29:22.538] result() for ClusterFuture ... done
[17:29:22.538] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:22.538] resolve() on list ...
[17:29:22.538]  recursive: 1
[17:29:22.539]  length: 2
[17:29:22.539]  elements: 'a', 'b'
[17:29:22.539]  length: 1 (resolved future 1)
[17:29:22.539]  length: 0 (resolved future 2)
[17:29:22.540] resolve() on list ... DONE
[17:29:22.540] A MultisessionFuture was resolved (and resolved itself)
- w/ exception ...
[17:29:22.540] getGlobalsAndPackages() ...
[17:29:22.541] Searching for globals...
[17:29:22.542] - globals found: [2] 'list', 'stop'
[17:29:22.542] Searching for globals ... DONE
[17:29:22.543] Resolving globals: FALSE
[17:29:22.543] 
[17:29:22.543] 
[17:29:22.544] getGlobalsAndPackages() ... DONE
[17:29:22.544] run() for 'Future' ...
[17:29:22.544] - state: 'created'
[17:29:22.545] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:22.564] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:22.565] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:22.565]   - Field: 'node'
[17:29:22.566]   - Field: 'label'
[17:29:22.566]   - Field: 'local'
[17:29:22.566]   - Field: 'owner'
[17:29:22.566]   - Field: 'envir'
[17:29:22.567]   - Field: 'workers'
[17:29:22.567]   - Field: 'packages'
[17:29:22.567]   - Field: 'gc'
[17:29:22.568]   - Field: 'conditions'
[17:29:22.568]   - Field: 'persistent'
[17:29:22.568]   - Field: 'expr'
[17:29:22.569]   - Field: 'uuid'
[17:29:22.569]   - Field: 'seed'
[17:29:22.569]   - Field: 'version'
[17:29:22.570]   - Field: 'result'
[17:29:22.570]   - Field: 'asynchronous'
[17:29:22.570]   - Field: 'calls'
[17:29:22.571]   - Field: 'globals'
[17:29:22.571]   - Field: 'stdout'
[17:29:22.571]   - Field: 'earlySignal'
[17:29:22.571]   - Field: 'lazy'
[17:29:22.574]   - Field: 'state'
[17:29:22.574] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:22.574] - Launch lazy future ...
[17:29:22.575] Packages needed by the future expression (n = 0): <none>
[17:29:22.575] Packages needed by future strategies (n = 0): <none>
[17:29:22.576] {
[17:29:22.576]     {
[17:29:22.576]         {
[17:29:22.576]             ...future.startTime <- base::Sys.time()
[17:29:22.576]             {
[17:29:22.576]                 {
[17:29:22.576]                   {
[17:29:22.576]                     {
[17:29:22.576]                       base::local({
[17:29:22.576]                         has_future <- base::requireNamespace("future", 
[17:29:22.576]                           quietly = TRUE)
[17:29:22.576]                         if (has_future) {
[17:29:22.576]                           ns <- base::getNamespace("future")
[17:29:22.576]                           version <- ns[[".package"]][["version"]]
[17:29:22.576]                           if (is.null(version)) 
[17:29:22.576]                             version <- utils::packageVersion("future")
[17:29:22.576]                         }
[17:29:22.576]                         else {
[17:29:22.576]                           version <- NULL
[17:29:22.576]                         }
[17:29:22.576]                         if (!has_future || version < "1.8.0") {
[17:29:22.576]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:22.576]                             "", base::R.version$version.string), 
[17:29:22.576]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:22.576]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:22.576]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:22.576]                               "release", "version")], collapse = " "), 
[17:29:22.576]                             hostname = base::Sys.info()[["nodename"]])
[17:29:22.576]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:22.576]                             info)
[17:29:22.576]                           info <- base::paste(info, collapse = "; ")
[17:29:22.576]                           if (!has_future) {
[17:29:22.576]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:22.576]                               info)
[17:29:22.576]                           }
[17:29:22.576]                           else {
[17:29:22.576]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:22.576]                               info, version)
[17:29:22.576]                           }
[17:29:22.576]                           base::stop(msg)
[17:29:22.576]                         }
[17:29:22.576]                       })
[17:29:22.576]                     }
[17:29:22.576]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:22.576]                     base::options(mc.cores = 1L)
[17:29:22.576]                   }
[17:29:22.576]                   ...future.strategy.old <- future::plan("list")
[17:29:22.576]                   options(future.plan = NULL)
[17:29:22.576]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:22.576]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:22.576]                 }
[17:29:22.576]                 ...future.workdir <- getwd()
[17:29:22.576]             }
[17:29:22.576]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:22.576]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:22.576]         }
[17:29:22.576]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:22.576]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:22.576]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:22.576]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:22.576]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:22.576]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:22.576]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:22.576]             base::names(...future.oldOptions))
[17:29:22.576]     }
[17:29:22.576]     if (FALSE) {
[17:29:22.576]     }
[17:29:22.576]     else {
[17:29:22.576]         if (TRUE) {
[17:29:22.576]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:22.576]                 open = "w")
[17:29:22.576]         }
[17:29:22.576]         else {
[17:29:22.576]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:22.576]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:22.576]         }
[17:29:22.576]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:22.576]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:22.576]             base::sink(type = "output", split = FALSE)
[17:29:22.576]             base::close(...future.stdout)
[17:29:22.576]         }, add = TRUE)
[17:29:22.576]     }
[17:29:22.576]     ...future.frame <- base::sys.nframe()
[17:29:22.576]     ...future.conditions <- base::list()
[17:29:22.576]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:22.576]     if (FALSE) {
[17:29:22.576]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:22.576]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:22.576]     }
[17:29:22.576]     ...future.result <- base::tryCatch({
[17:29:22.576]         base::withCallingHandlers({
[17:29:22.576]             ...future.value <- base::withVisible(base::local({
[17:29:22.576]                 ...future.makeSendCondition <- base::local({
[17:29:22.576]                   sendCondition <- NULL
[17:29:22.576]                   function(frame = 1L) {
[17:29:22.576]                     if (is.function(sendCondition)) 
[17:29:22.576]                       return(sendCondition)
[17:29:22.576]                     ns <- getNamespace("parallel")
[17:29:22.576]                     if (exists("sendData", mode = "function", 
[17:29:22.576]                       envir = ns)) {
[17:29:22.576]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:22.576]                         envir = ns)
[17:29:22.576]                       envir <- sys.frame(frame)
[17:29:22.576]                       master <- NULL
[17:29:22.576]                       while (!identical(envir, .GlobalEnv) && 
[17:29:22.576]                         !identical(envir, emptyenv())) {
[17:29:22.576]                         if (exists("master", mode = "list", envir = envir, 
[17:29:22.576]                           inherits = FALSE)) {
[17:29:22.576]                           master <- get("master", mode = "list", 
[17:29:22.576]                             envir = envir, inherits = FALSE)
[17:29:22.576]                           if (inherits(master, c("SOCKnode", 
[17:29:22.576]                             "SOCK0node"))) {
[17:29:22.576]                             sendCondition <<- function(cond) {
[17:29:22.576]                               data <- list(type = "VALUE", value = cond, 
[17:29:22.576]                                 success = TRUE)
[17:29:22.576]                               parallel_sendData(master, data)
[17:29:22.576]                             }
[17:29:22.576]                             return(sendCondition)
[17:29:22.576]                           }
[17:29:22.576]                         }
[17:29:22.576]                         frame <- frame + 1L
[17:29:22.576]                         envir <- sys.frame(frame)
[17:29:22.576]                       }
[17:29:22.576]                     }
[17:29:22.576]                     sendCondition <<- function(cond) NULL
[17:29:22.576]                   }
[17:29:22.576]                 })
[17:29:22.576]                 withCallingHandlers({
[17:29:22.576]                   list(a = 1, b = 42L, c = stop("Nah!"))
[17:29:22.576]                 }, immediateCondition = function(cond) {
[17:29:22.576]                   sendCondition <- ...future.makeSendCondition()
[17:29:22.576]                   sendCondition(cond)
[17:29:22.576]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:22.576]                   {
[17:29:22.576]                     inherits <- base::inherits
[17:29:22.576]                     invokeRestart <- base::invokeRestart
[17:29:22.576]                     is.null <- base::is.null
[17:29:22.576]                     muffled <- FALSE
[17:29:22.576]                     if (inherits(cond, "message")) {
[17:29:22.576]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:22.576]                       if (muffled) 
[17:29:22.576]                         invokeRestart("muffleMessage")
[17:29:22.576]                     }
[17:29:22.576]                     else if (inherits(cond, "warning")) {
[17:29:22.576]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:22.576]                       if (muffled) 
[17:29:22.576]                         invokeRestart("muffleWarning")
[17:29:22.576]                     }
[17:29:22.576]                     else if (inherits(cond, "condition")) {
[17:29:22.576]                       if (!is.null(pattern)) {
[17:29:22.576]                         computeRestarts <- base::computeRestarts
[17:29:22.576]                         grepl <- base::grepl
[17:29:22.576]                         restarts <- computeRestarts(cond)
[17:29:22.576]                         for (restart in restarts) {
[17:29:22.576]                           name <- restart$name
[17:29:22.576]                           if (is.null(name)) 
[17:29:22.576]                             next
[17:29:22.576]                           if (!grepl(pattern, name)) 
[17:29:22.576]                             next
[17:29:22.576]                           invokeRestart(restart)
[17:29:22.576]                           muffled <- TRUE
[17:29:22.576]                           break
[17:29:22.576]                         }
[17:29:22.576]                       }
[17:29:22.576]                     }
[17:29:22.576]                     invisible(muffled)
[17:29:22.576]                   }
[17:29:22.576]                   muffleCondition(cond)
[17:29:22.576]                 })
[17:29:22.576]             }))
[17:29:22.576]             future::FutureResult(value = ...future.value$value, 
[17:29:22.576]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:22.576]                   ...future.rng), globalenv = if (FALSE) 
[17:29:22.576]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:22.576]                     ...future.globalenv.names))
[17:29:22.576]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:22.576]         }, condition = base::local({
[17:29:22.576]             c <- base::c
[17:29:22.576]             inherits <- base::inherits
[17:29:22.576]             invokeRestart <- base::invokeRestart
[17:29:22.576]             length <- base::length
[17:29:22.576]             list <- base::list
[17:29:22.576]             seq.int <- base::seq.int
[17:29:22.576]             signalCondition <- base::signalCondition
[17:29:22.576]             sys.calls <- base::sys.calls
[17:29:22.576]             `[[` <- base::`[[`
[17:29:22.576]             `+` <- base::`+`
[17:29:22.576]             `<<-` <- base::`<<-`
[17:29:22.576]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:22.576]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:22.576]                   3L)]
[17:29:22.576]             }
[17:29:22.576]             function(cond) {
[17:29:22.576]                 is_error <- inherits(cond, "error")
[17:29:22.576]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:22.576]                   NULL)
[17:29:22.576]                 if (is_error) {
[17:29:22.576]                   sessionInformation <- function() {
[17:29:22.576]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:22.576]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:22.576]                       search = base::search(), system = base::Sys.info())
[17:29:22.576]                   }
[17:29:22.576]                   ...future.conditions[[length(...future.conditions) + 
[17:29:22.576]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:22.576]                     cond$call), session = sessionInformation(), 
[17:29:22.576]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:22.576]                   signalCondition(cond)
[17:29:22.576]                 }
[17:29:22.576]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:22.576]                 "immediateCondition"))) {
[17:29:22.576]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:22.576]                   ...future.conditions[[length(...future.conditions) + 
[17:29:22.576]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:22.576]                   if (TRUE && !signal) {
[17:29:22.576]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:22.576]                     {
[17:29:22.576]                       inherits <- base::inherits
[17:29:22.576]                       invokeRestart <- base::invokeRestart
[17:29:22.576]                       is.null <- base::is.null
[17:29:22.576]                       muffled <- FALSE
[17:29:22.576]                       if (inherits(cond, "message")) {
[17:29:22.576]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:22.576]                         if (muffled) 
[17:29:22.576]                           invokeRestart("muffleMessage")
[17:29:22.576]                       }
[17:29:22.576]                       else if (inherits(cond, "warning")) {
[17:29:22.576]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:22.576]                         if (muffled) 
[17:29:22.576]                           invokeRestart("muffleWarning")
[17:29:22.576]                       }
[17:29:22.576]                       else if (inherits(cond, "condition")) {
[17:29:22.576]                         if (!is.null(pattern)) {
[17:29:22.576]                           computeRestarts <- base::computeRestarts
[17:29:22.576]                           grepl <- base::grepl
[17:29:22.576]                           restarts <- computeRestarts(cond)
[17:29:22.576]                           for (restart in restarts) {
[17:29:22.576]                             name <- restart$name
[17:29:22.576]                             if (is.null(name)) 
[17:29:22.576]                               next
[17:29:22.576]                             if (!grepl(pattern, name)) 
[17:29:22.576]                               next
[17:29:22.576]                             invokeRestart(restart)
[17:29:22.576]                             muffled <- TRUE
[17:29:22.576]                             break
[17:29:22.576]                           }
[17:29:22.576]                         }
[17:29:22.576]                       }
[17:29:22.576]                       invisible(muffled)
[17:29:22.576]                     }
[17:29:22.576]                     muffleCondition(cond, pattern = "^muffle")
[17:29:22.576]                   }
[17:29:22.576]                 }
[17:29:22.576]                 else {
[17:29:22.576]                   if (TRUE) {
[17:29:22.576]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:22.576]                     {
[17:29:22.576]                       inherits <- base::inherits
[17:29:22.576]                       invokeRestart <- base::invokeRestart
[17:29:22.576]                       is.null <- base::is.null
[17:29:22.576]                       muffled <- FALSE
[17:29:22.576]                       if (inherits(cond, "message")) {
[17:29:22.576]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:22.576]                         if (muffled) 
[17:29:22.576]                           invokeRestart("muffleMessage")
[17:29:22.576]                       }
[17:29:22.576]                       else if (inherits(cond, "warning")) {
[17:29:22.576]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:22.576]                         if (muffled) 
[17:29:22.576]                           invokeRestart("muffleWarning")
[17:29:22.576]                       }
[17:29:22.576]                       else if (inherits(cond, "condition")) {
[17:29:22.576]                         if (!is.null(pattern)) {
[17:29:22.576]                           computeRestarts <- base::computeRestarts
[17:29:22.576]                           grepl <- base::grepl
[17:29:22.576]                           restarts <- computeRestarts(cond)
[17:29:22.576]                           for (restart in restarts) {
[17:29:22.576]                             name <- restart$name
[17:29:22.576]                             if (is.null(name)) 
[17:29:22.576]                               next
[17:29:22.576]                             if (!grepl(pattern, name)) 
[17:29:22.576]                               next
[17:29:22.576]                             invokeRestart(restart)
[17:29:22.576]                             muffled <- TRUE
[17:29:22.576]                             break
[17:29:22.576]                           }
[17:29:22.576]                         }
[17:29:22.576]                       }
[17:29:22.576]                       invisible(muffled)
[17:29:22.576]                     }
[17:29:22.576]                     muffleCondition(cond, pattern = "^muffle")
[17:29:22.576]                   }
[17:29:22.576]                 }
[17:29:22.576]             }
[17:29:22.576]         }))
[17:29:22.576]     }, error = function(ex) {
[17:29:22.576]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:22.576]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:22.576]                 ...future.rng), started = ...future.startTime, 
[17:29:22.576]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:22.576]             version = "1.8"), class = "FutureResult")
[17:29:22.576]     }, finally = {
[17:29:22.576]         if (!identical(...future.workdir, getwd())) 
[17:29:22.576]             setwd(...future.workdir)
[17:29:22.576]         {
[17:29:22.576]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:22.576]                 ...future.oldOptions$nwarnings <- NULL
[17:29:22.576]             }
[17:29:22.576]             base::options(...future.oldOptions)
[17:29:22.576]             if (.Platform$OS.type == "windows") {
[17:29:22.576]                 old_names <- names(...future.oldEnvVars)
[17:29:22.576]                 envs <- base::Sys.getenv()
[17:29:22.576]                 names <- names(envs)
[17:29:22.576]                 common <- intersect(names, old_names)
[17:29:22.576]                 added <- setdiff(names, old_names)
[17:29:22.576]                 removed <- setdiff(old_names, names)
[17:29:22.576]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:22.576]                   envs[common]]
[17:29:22.576]                 NAMES <- toupper(changed)
[17:29:22.576]                 args <- list()
[17:29:22.576]                 for (kk in seq_along(NAMES)) {
[17:29:22.576]                   name <- changed[[kk]]
[17:29:22.576]                   NAME <- NAMES[[kk]]
[17:29:22.576]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:22.576]                     next
[17:29:22.576]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:22.576]                 }
[17:29:22.576]                 NAMES <- toupper(added)
[17:29:22.576]                 for (kk in seq_along(NAMES)) {
[17:29:22.576]                   name <- added[[kk]]
[17:29:22.576]                   NAME <- NAMES[[kk]]
[17:29:22.576]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:22.576]                     next
[17:29:22.576]                   args[[name]] <- ""
[17:29:22.576]                 }
[17:29:22.576]                 NAMES <- toupper(removed)
[17:29:22.576]                 for (kk in seq_along(NAMES)) {
[17:29:22.576]                   name <- removed[[kk]]
[17:29:22.576]                   NAME <- NAMES[[kk]]
[17:29:22.576]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:22.576]                     next
[17:29:22.576]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:22.576]                 }
[17:29:22.576]                 if (length(args) > 0) 
[17:29:22.576]                   base::do.call(base::Sys.setenv, args = args)
[17:29:22.576]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:22.576]             }
[17:29:22.576]             else {
[17:29:22.576]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:22.576]             }
[17:29:22.576]             {
[17:29:22.576]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:22.576]                   0L) {
[17:29:22.576]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:22.576]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:22.576]                   base::options(opts)
[17:29:22.576]                 }
[17:29:22.576]                 {
[17:29:22.576]                   {
[17:29:22.576]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:22.576]                     NULL
[17:29:22.576]                   }
[17:29:22.576]                   options(future.plan = NULL)
[17:29:22.576]                   if (is.na(NA_character_)) 
[17:29:22.576]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:22.576]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:22.576]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:22.576]                     .init = FALSE)
[17:29:22.576]                 }
[17:29:22.576]             }
[17:29:22.576]         }
[17:29:22.576]     })
[17:29:22.576]     if (TRUE) {
[17:29:22.576]         base::sink(type = "output", split = FALSE)
[17:29:22.576]         if (TRUE) {
[17:29:22.576]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:22.576]         }
[17:29:22.576]         else {
[17:29:22.576]             ...future.result["stdout"] <- base::list(NULL)
[17:29:22.576]         }
[17:29:22.576]         base::close(...future.stdout)
[17:29:22.576]         ...future.stdout <- NULL
[17:29:22.576]     }
[17:29:22.576]     ...future.result$conditions <- ...future.conditions
[17:29:22.576]     ...future.result$finished <- base::Sys.time()
[17:29:22.576]     ...future.result
[17:29:22.576] }
[17:29:22.583] MultisessionFuture started
[17:29:22.583] - Launch lazy future ... done
[17:29:22.583] run() for 'MultisessionFuture' ... done
[17:29:22.610] receiveMessageFromWorker() for ClusterFuture ...
[17:29:22.611] - Validating connection of MultisessionFuture
[17:29:22.612] - received message: FutureResult
[17:29:22.612] - Received FutureResult
[17:29:22.613] - Erased future from FutureRegistry
[17:29:22.613] result() for ClusterFuture ...
[17:29:22.613] - result already collected: FutureResult
[17:29:22.613] result() for ClusterFuture ... done
[17:29:22.614] signalConditions() ...
[17:29:22.614]  - include = 'immediateCondition'
[17:29:22.614]  - exclude = 
[17:29:22.614]  - resignal = FALSE
[17:29:22.615]  - Number of conditions: 1
[17:29:22.615] signalConditions() ... done
[17:29:22.615] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:22.616] A MultisessionFuture was resolved (and resolved itself)
[17:29:22.616] getGlobalsAndPackages() ...
[17:29:22.616] Searching for globals...
[17:29:22.617] - globals found: [2] 'list', 'stop'
[17:29:22.618] Searching for globals ... DONE
[17:29:22.618] Resolving globals: FALSE
[17:29:22.619] 
[17:29:22.619] 
[17:29:22.619] getGlobalsAndPackages() ... DONE
[17:29:22.620] run() for 'Future' ...
[17:29:22.620] - state: 'created'
[17:29:22.620] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:22.639] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:22.639] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:22.639]   - Field: 'node'
[17:29:22.640]   - Field: 'label'
[17:29:22.640]   - Field: 'local'
[17:29:22.640]   - Field: 'owner'
[17:29:22.640]   - Field: 'envir'
[17:29:22.640]   - Field: 'workers'
[17:29:22.640]   - Field: 'packages'
[17:29:22.641]   - Field: 'gc'
[17:29:22.641]   - Field: 'conditions'
[17:29:22.641]   - Field: 'persistent'
[17:29:22.641]   - Field: 'expr'
[17:29:22.641]   - Field: 'uuid'
[17:29:22.642]   - Field: 'seed'
[17:29:22.642]   - Field: 'version'
[17:29:22.642]   - Field: 'result'
[17:29:22.642]   - Field: 'asynchronous'
[17:29:22.642]   - Field: 'calls'
[17:29:22.642]   - Field: 'globals'
[17:29:22.643]   - Field: 'stdout'
[17:29:22.643]   - Field: 'earlySignal'
[17:29:22.643]   - Field: 'lazy'
[17:29:22.643]   - Field: 'state'
[17:29:22.643] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:22.644] - Launch lazy future ...
[17:29:22.644] Packages needed by the future expression (n = 0): <none>
[17:29:22.645] Packages needed by future strategies (n = 0): <none>
[17:29:22.646] {
[17:29:22.646]     {
[17:29:22.646]         {
[17:29:22.646]             ...future.startTime <- base::Sys.time()
[17:29:22.646]             {
[17:29:22.646]                 {
[17:29:22.646]                   {
[17:29:22.646]                     {
[17:29:22.646]                       base::local({
[17:29:22.646]                         has_future <- base::requireNamespace("future", 
[17:29:22.646]                           quietly = TRUE)
[17:29:22.646]                         if (has_future) {
[17:29:22.646]                           ns <- base::getNamespace("future")
[17:29:22.646]                           version <- ns[[".package"]][["version"]]
[17:29:22.646]                           if (is.null(version)) 
[17:29:22.646]                             version <- utils::packageVersion("future")
[17:29:22.646]                         }
[17:29:22.646]                         else {
[17:29:22.646]                           version <- NULL
[17:29:22.646]                         }
[17:29:22.646]                         if (!has_future || version < "1.8.0") {
[17:29:22.646]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:22.646]                             "", base::R.version$version.string), 
[17:29:22.646]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:22.646]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:22.646]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:22.646]                               "release", "version")], collapse = " "), 
[17:29:22.646]                             hostname = base::Sys.info()[["nodename"]])
[17:29:22.646]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:22.646]                             info)
[17:29:22.646]                           info <- base::paste(info, collapse = "; ")
[17:29:22.646]                           if (!has_future) {
[17:29:22.646]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:22.646]                               info)
[17:29:22.646]                           }
[17:29:22.646]                           else {
[17:29:22.646]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:22.646]                               info, version)
[17:29:22.646]                           }
[17:29:22.646]                           base::stop(msg)
[17:29:22.646]                         }
[17:29:22.646]                       })
[17:29:22.646]                     }
[17:29:22.646]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:22.646]                     base::options(mc.cores = 1L)
[17:29:22.646]                   }
[17:29:22.646]                   ...future.strategy.old <- future::plan("list")
[17:29:22.646]                   options(future.plan = NULL)
[17:29:22.646]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:22.646]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:22.646]                 }
[17:29:22.646]                 ...future.workdir <- getwd()
[17:29:22.646]             }
[17:29:22.646]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:22.646]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:22.646]         }
[17:29:22.646]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:22.646]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:22.646]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:22.646]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:22.646]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:22.646]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:22.646]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:22.646]             base::names(...future.oldOptions))
[17:29:22.646]     }
[17:29:22.646]     if (FALSE) {
[17:29:22.646]     }
[17:29:22.646]     else {
[17:29:22.646]         if (TRUE) {
[17:29:22.646]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:22.646]                 open = "w")
[17:29:22.646]         }
[17:29:22.646]         else {
[17:29:22.646]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:22.646]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:22.646]         }
[17:29:22.646]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:22.646]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:22.646]             base::sink(type = "output", split = FALSE)
[17:29:22.646]             base::close(...future.stdout)
[17:29:22.646]         }, add = TRUE)
[17:29:22.646]     }
[17:29:22.646]     ...future.frame <- base::sys.nframe()
[17:29:22.646]     ...future.conditions <- base::list()
[17:29:22.646]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:22.646]     if (FALSE) {
[17:29:22.646]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:22.646]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:22.646]     }
[17:29:22.646]     ...future.result <- base::tryCatch({
[17:29:22.646]         base::withCallingHandlers({
[17:29:22.646]             ...future.value <- base::withVisible(base::local({
[17:29:22.646]                 ...future.makeSendCondition <- base::local({
[17:29:22.646]                   sendCondition <- NULL
[17:29:22.646]                   function(frame = 1L) {
[17:29:22.646]                     if (is.function(sendCondition)) 
[17:29:22.646]                       return(sendCondition)
[17:29:22.646]                     ns <- getNamespace("parallel")
[17:29:22.646]                     if (exists("sendData", mode = "function", 
[17:29:22.646]                       envir = ns)) {
[17:29:22.646]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:22.646]                         envir = ns)
[17:29:22.646]                       envir <- sys.frame(frame)
[17:29:22.646]                       master <- NULL
[17:29:22.646]                       while (!identical(envir, .GlobalEnv) && 
[17:29:22.646]                         !identical(envir, emptyenv())) {
[17:29:22.646]                         if (exists("master", mode = "list", envir = envir, 
[17:29:22.646]                           inherits = FALSE)) {
[17:29:22.646]                           master <- get("master", mode = "list", 
[17:29:22.646]                             envir = envir, inherits = FALSE)
[17:29:22.646]                           if (inherits(master, c("SOCKnode", 
[17:29:22.646]                             "SOCK0node"))) {
[17:29:22.646]                             sendCondition <<- function(cond) {
[17:29:22.646]                               data <- list(type = "VALUE", value = cond, 
[17:29:22.646]                                 success = TRUE)
[17:29:22.646]                               parallel_sendData(master, data)
[17:29:22.646]                             }
[17:29:22.646]                             return(sendCondition)
[17:29:22.646]                           }
[17:29:22.646]                         }
[17:29:22.646]                         frame <- frame + 1L
[17:29:22.646]                         envir <- sys.frame(frame)
[17:29:22.646]                       }
[17:29:22.646]                     }
[17:29:22.646]                     sendCondition <<- function(cond) NULL
[17:29:22.646]                   }
[17:29:22.646]                 })
[17:29:22.646]                 withCallingHandlers({
[17:29:22.646]                   list(a = 1, b = 42L, c = stop("Nah!"))
[17:29:22.646]                 }, immediateCondition = function(cond) {
[17:29:22.646]                   sendCondition <- ...future.makeSendCondition()
[17:29:22.646]                   sendCondition(cond)
[17:29:22.646]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:22.646]                   {
[17:29:22.646]                     inherits <- base::inherits
[17:29:22.646]                     invokeRestart <- base::invokeRestart
[17:29:22.646]                     is.null <- base::is.null
[17:29:22.646]                     muffled <- FALSE
[17:29:22.646]                     if (inherits(cond, "message")) {
[17:29:22.646]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:22.646]                       if (muffled) 
[17:29:22.646]                         invokeRestart("muffleMessage")
[17:29:22.646]                     }
[17:29:22.646]                     else if (inherits(cond, "warning")) {
[17:29:22.646]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:22.646]                       if (muffled) 
[17:29:22.646]                         invokeRestart("muffleWarning")
[17:29:22.646]                     }
[17:29:22.646]                     else if (inherits(cond, "condition")) {
[17:29:22.646]                       if (!is.null(pattern)) {
[17:29:22.646]                         computeRestarts <- base::computeRestarts
[17:29:22.646]                         grepl <- base::grepl
[17:29:22.646]                         restarts <- computeRestarts(cond)
[17:29:22.646]                         for (restart in restarts) {
[17:29:22.646]                           name <- restart$name
[17:29:22.646]                           if (is.null(name)) 
[17:29:22.646]                             next
[17:29:22.646]                           if (!grepl(pattern, name)) 
[17:29:22.646]                             next
[17:29:22.646]                           invokeRestart(restart)
[17:29:22.646]                           muffled <- TRUE
[17:29:22.646]                           break
[17:29:22.646]                         }
[17:29:22.646]                       }
[17:29:22.646]                     }
[17:29:22.646]                     invisible(muffled)
[17:29:22.646]                   }
[17:29:22.646]                   muffleCondition(cond)
[17:29:22.646]                 })
[17:29:22.646]             }))
[17:29:22.646]             future::FutureResult(value = ...future.value$value, 
[17:29:22.646]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:22.646]                   ...future.rng), globalenv = if (FALSE) 
[17:29:22.646]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:22.646]                     ...future.globalenv.names))
[17:29:22.646]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:22.646]         }, condition = base::local({
[17:29:22.646]             c <- base::c
[17:29:22.646]             inherits <- base::inherits
[17:29:22.646]             invokeRestart <- base::invokeRestart
[17:29:22.646]             length <- base::length
[17:29:22.646]             list <- base::list
[17:29:22.646]             seq.int <- base::seq.int
[17:29:22.646]             signalCondition <- base::signalCondition
[17:29:22.646]             sys.calls <- base::sys.calls
[17:29:22.646]             `[[` <- base::`[[`
[17:29:22.646]             `+` <- base::`+`
[17:29:22.646]             `<<-` <- base::`<<-`
[17:29:22.646]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:22.646]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:22.646]                   3L)]
[17:29:22.646]             }
[17:29:22.646]             function(cond) {
[17:29:22.646]                 is_error <- inherits(cond, "error")
[17:29:22.646]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:22.646]                   NULL)
[17:29:22.646]                 if (is_error) {
[17:29:22.646]                   sessionInformation <- function() {
[17:29:22.646]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:22.646]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:22.646]                       search = base::search(), system = base::Sys.info())
[17:29:22.646]                   }
[17:29:22.646]                   ...future.conditions[[length(...future.conditions) + 
[17:29:22.646]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:22.646]                     cond$call), session = sessionInformation(), 
[17:29:22.646]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:22.646]                   signalCondition(cond)
[17:29:22.646]                 }
[17:29:22.646]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:22.646]                 "immediateCondition"))) {
[17:29:22.646]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:22.646]                   ...future.conditions[[length(...future.conditions) + 
[17:29:22.646]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:22.646]                   if (TRUE && !signal) {
[17:29:22.646]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:22.646]                     {
[17:29:22.646]                       inherits <- base::inherits
[17:29:22.646]                       invokeRestart <- base::invokeRestart
[17:29:22.646]                       is.null <- base::is.null
[17:29:22.646]                       muffled <- FALSE
[17:29:22.646]                       if (inherits(cond, "message")) {
[17:29:22.646]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:22.646]                         if (muffled) 
[17:29:22.646]                           invokeRestart("muffleMessage")
[17:29:22.646]                       }
[17:29:22.646]                       else if (inherits(cond, "warning")) {
[17:29:22.646]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:22.646]                         if (muffled) 
[17:29:22.646]                           invokeRestart("muffleWarning")
[17:29:22.646]                       }
[17:29:22.646]                       else if (inherits(cond, "condition")) {
[17:29:22.646]                         if (!is.null(pattern)) {
[17:29:22.646]                           computeRestarts <- base::computeRestarts
[17:29:22.646]                           grepl <- base::grepl
[17:29:22.646]                           restarts <- computeRestarts(cond)
[17:29:22.646]                           for (restart in restarts) {
[17:29:22.646]                             name <- restart$name
[17:29:22.646]                             if (is.null(name)) 
[17:29:22.646]                               next
[17:29:22.646]                             if (!grepl(pattern, name)) 
[17:29:22.646]                               next
[17:29:22.646]                             invokeRestart(restart)
[17:29:22.646]                             muffled <- TRUE
[17:29:22.646]                             break
[17:29:22.646]                           }
[17:29:22.646]                         }
[17:29:22.646]                       }
[17:29:22.646]                       invisible(muffled)
[17:29:22.646]                     }
[17:29:22.646]                     muffleCondition(cond, pattern = "^muffle")
[17:29:22.646]                   }
[17:29:22.646]                 }
[17:29:22.646]                 else {
[17:29:22.646]                   if (TRUE) {
[17:29:22.646]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:22.646]                     {
[17:29:22.646]                       inherits <- base::inherits
[17:29:22.646]                       invokeRestart <- base::invokeRestart
[17:29:22.646]                       is.null <- base::is.null
[17:29:22.646]                       muffled <- FALSE
[17:29:22.646]                       if (inherits(cond, "message")) {
[17:29:22.646]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:22.646]                         if (muffled) 
[17:29:22.646]                           invokeRestart("muffleMessage")
[17:29:22.646]                       }
[17:29:22.646]                       else if (inherits(cond, "warning")) {
[17:29:22.646]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:22.646]                         if (muffled) 
[17:29:22.646]                           invokeRestart("muffleWarning")
[17:29:22.646]                       }
[17:29:22.646]                       else if (inherits(cond, "condition")) {
[17:29:22.646]                         if (!is.null(pattern)) {
[17:29:22.646]                           computeRestarts <- base::computeRestarts
[17:29:22.646]                           grepl <- base::grepl
[17:29:22.646]                           restarts <- computeRestarts(cond)
[17:29:22.646]                           for (restart in restarts) {
[17:29:22.646]                             name <- restart$name
[17:29:22.646]                             if (is.null(name)) 
[17:29:22.646]                               next
[17:29:22.646]                             if (!grepl(pattern, name)) 
[17:29:22.646]                               next
[17:29:22.646]                             invokeRestart(restart)
[17:29:22.646]                             muffled <- TRUE
[17:29:22.646]                             break
[17:29:22.646]                           }
[17:29:22.646]                         }
[17:29:22.646]                       }
[17:29:22.646]                       invisible(muffled)
[17:29:22.646]                     }
[17:29:22.646]                     muffleCondition(cond, pattern = "^muffle")
[17:29:22.646]                   }
[17:29:22.646]                 }
[17:29:22.646]             }
[17:29:22.646]         }))
[17:29:22.646]     }, error = function(ex) {
[17:29:22.646]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:22.646]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:22.646]                 ...future.rng), started = ...future.startTime, 
[17:29:22.646]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:22.646]             version = "1.8"), class = "FutureResult")
[17:29:22.646]     }, finally = {
[17:29:22.646]         if (!identical(...future.workdir, getwd())) 
[17:29:22.646]             setwd(...future.workdir)
[17:29:22.646]         {
[17:29:22.646]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:22.646]                 ...future.oldOptions$nwarnings <- NULL
[17:29:22.646]             }
[17:29:22.646]             base::options(...future.oldOptions)
[17:29:22.646]             if (.Platform$OS.type == "windows") {
[17:29:22.646]                 old_names <- names(...future.oldEnvVars)
[17:29:22.646]                 envs <- base::Sys.getenv()
[17:29:22.646]                 names <- names(envs)
[17:29:22.646]                 common <- intersect(names, old_names)
[17:29:22.646]                 added <- setdiff(names, old_names)
[17:29:22.646]                 removed <- setdiff(old_names, names)
[17:29:22.646]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:22.646]                   envs[common]]
[17:29:22.646]                 NAMES <- toupper(changed)
[17:29:22.646]                 args <- list()
[17:29:22.646]                 for (kk in seq_along(NAMES)) {
[17:29:22.646]                   name <- changed[[kk]]
[17:29:22.646]                   NAME <- NAMES[[kk]]
[17:29:22.646]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:22.646]                     next
[17:29:22.646]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:22.646]                 }
[17:29:22.646]                 NAMES <- toupper(added)
[17:29:22.646]                 for (kk in seq_along(NAMES)) {
[17:29:22.646]                   name <- added[[kk]]
[17:29:22.646]                   NAME <- NAMES[[kk]]
[17:29:22.646]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:22.646]                     next
[17:29:22.646]                   args[[name]] <- ""
[17:29:22.646]                 }
[17:29:22.646]                 NAMES <- toupper(removed)
[17:29:22.646]                 for (kk in seq_along(NAMES)) {
[17:29:22.646]                   name <- removed[[kk]]
[17:29:22.646]                   NAME <- NAMES[[kk]]
[17:29:22.646]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:22.646]                     next
[17:29:22.646]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:22.646]                 }
[17:29:22.646]                 if (length(args) > 0) 
[17:29:22.646]                   base::do.call(base::Sys.setenv, args = args)
[17:29:22.646]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:22.646]             }
[17:29:22.646]             else {
[17:29:22.646]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:22.646]             }
[17:29:22.646]             {
[17:29:22.646]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:22.646]                   0L) {
[17:29:22.646]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:22.646]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:22.646]                   base::options(opts)
[17:29:22.646]                 }
[17:29:22.646]                 {
[17:29:22.646]                   {
[17:29:22.646]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:22.646]                     NULL
[17:29:22.646]                   }
[17:29:22.646]                   options(future.plan = NULL)
[17:29:22.646]                   if (is.na(NA_character_)) 
[17:29:22.646]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:22.646]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:22.646]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:22.646]                     .init = FALSE)
[17:29:22.646]                 }
[17:29:22.646]             }
[17:29:22.646]         }
[17:29:22.646]     })
[17:29:22.646]     if (TRUE) {
[17:29:22.646]         base::sink(type = "output", split = FALSE)
[17:29:22.646]         if (TRUE) {
[17:29:22.646]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:22.646]         }
[17:29:22.646]         else {
[17:29:22.646]             ...future.result["stdout"] <- base::list(NULL)
[17:29:22.646]         }
[17:29:22.646]         base::close(...future.stdout)
[17:29:22.646]         ...future.stdout <- NULL
[17:29:22.646]     }
[17:29:22.646]     ...future.result$conditions <- ...future.conditions
[17:29:22.646]     ...future.result$finished <- base::Sys.time()
[17:29:22.646]     ...future.result
[17:29:22.646] }
[17:29:22.655] MultisessionFuture started
[17:29:22.655] - Launch lazy future ... done
[17:29:22.655] run() for 'MultisessionFuture' ... done
[17:29:22.682] receiveMessageFromWorker() for ClusterFuture ...
[17:29:22.683] - Validating connection of MultisessionFuture
[17:29:22.684] - received message: FutureResult
[17:29:22.684] - Received FutureResult
[17:29:22.684] - Erased future from FutureRegistry
[17:29:22.684] result() for ClusterFuture ...
[17:29:22.685] - result already collected: FutureResult
[17:29:22.685] result() for ClusterFuture ... done
[17:29:22.685] signalConditions() ...
[17:29:22.685]  - include = 'immediateCondition'
[17:29:22.686]  - exclude = 
[17:29:22.686]  - resignal = FALSE
[17:29:22.686]  - Number of conditions: 1
[17:29:22.686] signalConditions() ... done
[17:29:22.686] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:22.687] A MultisessionFuture was resolved (and resolved itself)
- result = TRUE, recursive = 2 ... DONE
- result = TRUE, recursive = Inf ...
[17:29:22.687] getGlobalsAndPackages() ...
[17:29:22.687] Searching for globals...
[17:29:22.689] - globals found: [3] '{', 'Sys.sleep', 'list'
[17:29:22.689] Searching for globals ... DONE
[17:29:22.689] Resolving globals: FALSE
[17:29:22.690] 
[17:29:22.690] 
[17:29:22.690] getGlobalsAndPackages() ... DONE
[17:29:22.690] run() for 'Future' ...
[17:29:22.691] - state: 'created'
[17:29:22.691] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:22.716] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:22.716] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:22.716]   - Field: 'node'
[17:29:22.716]   - Field: 'label'
[17:29:22.716]   - Field: 'local'
[17:29:22.717]   - Field: 'owner'
[17:29:22.717]   - Field: 'envir'
[17:29:22.717]   - Field: 'workers'
[17:29:22.717]   - Field: 'packages'
[17:29:22.717]   - Field: 'gc'
[17:29:22.718]   - Field: 'conditions'
[17:29:22.718]   - Field: 'persistent'
[17:29:22.718]   - Field: 'expr'
[17:29:22.718]   - Field: 'uuid'
[17:29:22.718]   - Field: 'seed'
[17:29:22.718]   - Field: 'version'
[17:29:22.719]   - Field: 'result'
[17:29:22.719]   - Field: 'asynchronous'
[17:29:22.719]   - Field: 'calls'
[17:29:22.719]   - Field: 'globals'
[17:29:22.719]   - Field: 'stdout'
[17:29:22.719]   - Field: 'earlySignal'
[17:29:22.720]   - Field: 'lazy'
[17:29:22.720]   - Field: 'state'
[17:29:22.720] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:22.720] - Launch lazy future ...
[17:29:22.721] Packages needed by the future expression (n = 0): <none>
[17:29:22.721] Packages needed by future strategies (n = 0): <none>
[17:29:22.721] {
[17:29:22.721]     {
[17:29:22.721]         {
[17:29:22.721]             ...future.startTime <- base::Sys.time()
[17:29:22.721]             {
[17:29:22.721]                 {
[17:29:22.721]                   {
[17:29:22.721]                     {
[17:29:22.721]                       base::local({
[17:29:22.721]                         has_future <- base::requireNamespace("future", 
[17:29:22.721]                           quietly = TRUE)
[17:29:22.721]                         if (has_future) {
[17:29:22.721]                           ns <- base::getNamespace("future")
[17:29:22.721]                           version <- ns[[".package"]][["version"]]
[17:29:22.721]                           if (is.null(version)) 
[17:29:22.721]                             version <- utils::packageVersion("future")
[17:29:22.721]                         }
[17:29:22.721]                         else {
[17:29:22.721]                           version <- NULL
[17:29:22.721]                         }
[17:29:22.721]                         if (!has_future || version < "1.8.0") {
[17:29:22.721]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:22.721]                             "", base::R.version$version.string), 
[17:29:22.721]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:22.721]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:22.721]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:22.721]                               "release", "version")], collapse = " "), 
[17:29:22.721]                             hostname = base::Sys.info()[["nodename"]])
[17:29:22.721]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:22.721]                             info)
[17:29:22.721]                           info <- base::paste(info, collapse = "; ")
[17:29:22.721]                           if (!has_future) {
[17:29:22.721]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:22.721]                               info)
[17:29:22.721]                           }
[17:29:22.721]                           else {
[17:29:22.721]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:22.721]                               info, version)
[17:29:22.721]                           }
[17:29:22.721]                           base::stop(msg)
[17:29:22.721]                         }
[17:29:22.721]                       })
[17:29:22.721]                     }
[17:29:22.721]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:22.721]                     base::options(mc.cores = 1L)
[17:29:22.721]                   }
[17:29:22.721]                   ...future.strategy.old <- future::plan("list")
[17:29:22.721]                   options(future.plan = NULL)
[17:29:22.721]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:22.721]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:22.721]                 }
[17:29:22.721]                 ...future.workdir <- getwd()
[17:29:22.721]             }
[17:29:22.721]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:22.721]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:22.721]         }
[17:29:22.721]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:22.721]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:22.721]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:22.721]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:22.721]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:22.721]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:22.721]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:22.721]             base::names(...future.oldOptions))
[17:29:22.721]     }
[17:29:22.721]     if (FALSE) {
[17:29:22.721]     }
[17:29:22.721]     else {
[17:29:22.721]         if (TRUE) {
[17:29:22.721]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:22.721]                 open = "w")
[17:29:22.721]         }
[17:29:22.721]         else {
[17:29:22.721]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:22.721]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:22.721]         }
[17:29:22.721]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:22.721]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:22.721]             base::sink(type = "output", split = FALSE)
[17:29:22.721]             base::close(...future.stdout)
[17:29:22.721]         }, add = TRUE)
[17:29:22.721]     }
[17:29:22.721]     ...future.frame <- base::sys.nframe()
[17:29:22.721]     ...future.conditions <- base::list()
[17:29:22.721]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:22.721]     if (FALSE) {
[17:29:22.721]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:22.721]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:22.721]     }
[17:29:22.721]     ...future.result <- base::tryCatch({
[17:29:22.721]         base::withCallingHandlers({
[17:29:22.721]             ...future.value <- base::withVisible(base::local({
[17:29:22.721]                 ...future.makeSendCondition <- base::local({
[17:29:22.721]                   sendCondition <- NULL
[17:29:22.721]                   function(frame = 1L) {
[17:29:22.721]                     if (is.function(sendCondition)) 
[17:29:22.721]                       return(sendCondition)
[17:29:22.721]                     ns <- getNamespace("parallel")
[17:29:22.721]                     if (exists("sendData", mode = "function", 
[17:29:22.721]                       envir = ns)) {
[17:29:22.721]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:22.721]                         envir = ns)
[17:29:22.721]                       envir <- sys.frame(frame)
[17:29:22.721]                       master <- NULL
[17:29:22.721]                       while (!identical(envir, .GlobalEnv) && 
[17:29:22.721]                         !identical(envir, emptyenv())) {
[17:29:22.721]                         if (exists("master", mode = "list", envir = envir, 
[17:29:22.721]                           inherits = FALSE)) {
[17:29:22.721]                           master <- get("master", mode = "list", 
[17:29:22.721]                             envir = envir, inherits = FALSE)
[17:29:22.721]                           if (inherits(master, c("SOCKnode", 
[17:29:22.721]                             "SOCK0node"))) {
[17:29:22.721]                             sendCondition <<- function(cond) {
[17:29:22.721]                               data <- list(type = "VALUE", value = cond, 
[17:29:22.721]                                 success = TRUE)
[17:29:22.721]                               parallel_sendData(master, data)
[17:29:22.721]                             }
[17:29:22.721]                             return(sendCondition)
[17:29:22.721]                           }
[17:29:22.721]                         }
[17:29:22.721]                         frame <- frame + 1L
[17:29:22.721]                         envir <- sys.frame(frame)
[17:29:22.721]                       }
[17:29:22.721]                     }
[17:29:22.721]                     sendCondition <<- function(cond) NULL
[17:29:22.721]                   }
[17:29:22.721]                 })
[17:29:22.721]                 withCallingHandlers({
[17:29:22.721]                   {
[17:29:22.721]                     Sys.sleep(0.5)
[17:29:22.721]                     list(a = 1, b = 42L)
[17:29:22.721]                   }
[17:29:22.721]                 }, immediateCondition = function(cond) {
[17:29:22.721]                   sendCondition <- ...future.makeSendCondition()
[17:29:22.721]                   sendCondition(cond)
[17:29:22.721]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:22.721]                   {
[17:29:22.721]                     inherits <- base::inherits
[17:29:22.721]                     invokeRestart <- base::invokeRestart
[17:29:22.721]                     is.null <- base::is.null
[17:29:22.721]                     muffled <- FALSE
[17:29:22.721]                     if (inherits(cond, "message")) {
[17:29:22.721]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:22.721]                       if (muffled) 
[17:29:22.721]                         invokeRestart("muffleMessage")
[17:29:22.721]                     }
[17:29:22.721]                     else if (inherits(cond, "warning")) {
[17:29:22.721]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:22.721]                       if (muffled) 
[17:29:22.721]                         invokeRestart("muffleWarning")
[17:29:22.721]                     }
[17:29:22.721]                     else if (inherits(cond, "condition")) {
[17:29:22.721]                       if (!is.null(pattern)) {
[17:29:22.721]                         computeRestarts <- base::computeRestarts
[17:29:22.721]                         grepl <- base::grepl
[17:29:22.721]                         restarts <- computeRestarts(cond)
[17:29:22.721]                         for (restart in restarts) {
[17:29:22.721]                           name <- restart$name
[17:29:22.721]                           if (is.null(name)) 
[17:29:22.721]                             next
[17:29:22.721]                           if (!grepl(pattern, name)) 
[17:29:22.721]                             next
[17:29:22.721]                           invokeRestart(restart)
[17:29:22.721]                           muffled <- TRUE
[17:29:22.721]                           break
[17:29:22.721]                         }
[17:29:22.721]                       }
[17:29:22.721]                     }
[17:29:22.721]                     invisible(muffled)
[17:29:22.721]                   }
[17:29:22.721]                   muffleCondition(cond)
[17:29:22.721]                 })
[17:29:22.721]             }))
[17:29:22.721]             future::FutureResult(value = ...future.value$value, 
[17:29:22.721]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:22.721]                   ...future.rng), globalenv = if (FALSE) 
[17:29:22.721]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:22.721]                     ...future.globalenv.names))
[17:29:22.721]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:22.721]         }, condition = base::local({
[17:29:22.721]             c <- base::c
[17:29:22.721]             inherits <- base::inherits
[17:29:22.721]             invokeRestart <- base::invokeRestart
[17:29:22.721]             length <- base::length
[17:29:22.721]             list <- base::list
[17:29:22.721]             seq.int <- base::seq.int
[17:29:22.721]             signalCondition <- base::signalCondition
[17:29:22.721]             sys.calls <- base::sys.calls
[17:29:22.721]             `[[` <- base::`[[`
[17:29:22.721]             `+` <- base::`+`
[17:29:22.721]             `<<-` <- base::`<<-`
[17:29:22.721]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:22.721]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:22.721]                   3L)]
[17:29:22.721]             }
[17:29:22.721]             function(cond) {
[17:29:22.721]                 is_error <- inherits(cond, "error")
[17:29:22.721]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:22.721]                   NULL)
[17:29:22.721]                 if (is_error) {
[17:29:22.721]                   sessionInformation <- function() {
[17:29:22.721]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:22.721]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:22.721]                       search = base::search(), system = base::Sys.info())
[17:29:22.721]                   }
[17:29:22.721]                   ...future.conditions[[length(...future.conditions) + 
[17:29:22.721]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:22.721]                     cond$call), session = sessionInformation(), 
[17:29:22.721]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:22.721]                   signalCondition(cond)
[17:29:22.721]                 }
[17:29:22.721]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:22.721]                 "immediateCondition"))) {
[17:29:22.721]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:22.721]                   ...future.conditions[[length(...future.conditions) + 
[17:29:22.721]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:22.721]                   if (TRUE && !signal) {
[17:29:22.721]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:22.721]                     {
[17:29:22.721]                       inherits <- base::inherits
[17:29:22.721]                       invokeRestart <- base::invokeRestart
[17:29:22.721]                       is.null <- base::is.null
[17:29:22.721]                       muffled <- FALSE
[17:29:22.721]                       if (inherits(cond, "message")) {
[17:29:22.721]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:22.721]                         if (muffled) 
[17:29:22.721]                           invokeRestart("muffleMessage")
[17:29:22.721]                       }
[17:29:22.721]                       else if (inherits(cond, "warning")) {
[17:29:22.721]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:22.721]                         if (muffled) 
[17:29:22.721]                           invokeRestart("muffleWarning")
[17:29:22.721]                       }
[17:29:22.721]                       else if (inherits(cond, "condition")) {
[17:29:22.721]                         if (!is.null(pattern)) {
[17:29:22.721]                           computeRestarts <- base::computeRestarts
[17:29:22.721]                           grepl <- base::grepl
[17:29:22.721]                           restarts <- computeRestarts(cond)
[17:29:22.721]                           for (restart in restarts) {
[17:29:22.721]                             name <- restart$name
[17:29:22.721]                             if (is.null(name)) 
[17:29:22.721]                               next
[17:29:22.721]                             if (!grepl(pattern, name)) 
[17:29:22.721]                               next
[17:29:22.721]                             invokeRestart(restart)
[17:29:22.721]                             muffled <- TRUE
[17:29:22.721]                             break
[17:29:22.721]                           }
[17:29:22.721]                         }
[17:29:22.721]                       }
[17:29:22.721]                       invisible(muffled)
[17:29:22.721]                     }
[17:29:22.721]                     muffleCondition(cond, pattern = "^muffle")
[17:29:22.721]                   }
[17:29:22.721]                 }
[17:29:22.721]                 else {
[17:29:22.721]                   if (TRUE) {
[17:29:22.721]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:22.721]                     {
[17:29:22.721]                       inherits <- base::inherits
[17:29:22.721]                       invokeRestart <- base::invokeRestart
[17:29:22.721]                       is.null <- base::is.null
[17:29:22.721]                       muffled <- FALSE
[17:29:22.721]                       if (inherits(cond, "message")) {
[17:29:22.721]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:22.721]                         if (muffled) 
[17:29:22.721]                           invokeRestart("muffleMessage")
[17:29:22.721]                       }
[17:29:22.721]                       else if (inherits(cond, "warning")) {
[17:29:22.721]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:22.721]                         if (muffled) 
[17:29:22.721]                           invokeRestart("muffleWarning")
[17:29:22.721]                       }
[17:29:22.721]                       else if (inherits(cond, "condition")) {
[17:29:22.721]                         if (!is.null(pattern)) {
[17:29:22.721]                           computeRestarts <- base::computeRestarts
[17:29:22.721]                           grepl <- base::grepl
[17:29:22.721]                           restarts <- computeRestarts(cond)
[17:29:22.721]                           for (restart in restarts) {
[17:29:22.721]                             name <- restart$name
[17:29:22.721]                             if (is.null(name)) 
[17:29:22.721]                               next
[17:29:22.721]                             if (!grepl(pattern, name)) 
[17:29:22.721]                               next
[17:29:22.721]                             invokeRestart(restart)
[17:29:22.721]                             muffled <- TRUE
[17:29:22.721]                             break
[17:29:22.721]                           }
[17:29:22.721]                         }
[17:29:22.721]                       }
[17:29:22.721]                       invisible(muffled)
[17:29:22.721]                     }
[17:29:22.721]                     muffleCondition(cond, pattern = "^muffle")
[17:29:22.721]                   }
[17:29:22.721]                 }
[17:29:22.721]             }
[17:29:22.721]         }))
[17:29:22.721]     }, error = function(ex) {
[17:29:22.721]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:22.721]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:22.721]                 ...future.rng), started = ...future.startTime, 
[17:29:22.721]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:22.721]             version = "1.8"), class = "FutureResult")
[17:29:22.721]     }, finally = {
[17:29:22.721]         if (!identical(...future.workdir, getwd())) 
[17:29:22.721]             setwd(...future.workdir)
[17:29:22.721]         {
[17:29:22.721]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:22.721]                 ...future.oldOptions$nwarnings <- NULL
[17:29:22.721]             }
[17:29:22.721]             base::options(...future.oldOptions)
[17:29:22.721]             if (.Platform$OS.type == "windows") {
[17:29:22.721]                 old_names <- names(...future.oldEnvVars)
[17:29:22.721]                 envs <- base::Sys.getenv()
[17:29:22.721]                 names <- names(envs)
[17:29:22.721]                 common <- intersect(names, old_names)
[17:29:22.721]                 added <- setdiff(names, old_names)
[17:29:22.721]                 removed <- setdiff(old_names, names)
[17:29:22.721]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:22.721]                   envs[common]]
[17:29:22.721]                 NAMES <- toupper(changed)
[17:29:22.721]                 args <- list()
[17:29:22.721]                 for (kk in seq_along(NAMES)) {
[17:29:22.721]                   name <- changed[[kk]]
[17:29:22.721]                   NAME <- NAMES[[kk]]
[17:29:22.721]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:22.721]                     next
[17:29:22.721]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:22.721]                 }
[17:29:22.721]                 NAMES <- toupper(added)
[17:29:22.721]                 for (kk in seq_along(NAMES)) {
[17:29:22.721]                   name <- added[[kk]]
[17:29:22.721]                   NAME <- NAMES[[kk]]
[17:29:22.721]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:22.721]                     next
[17:29:22.721]                   args[[name]] <- ""
[17:29:22.721]                 }
[17:29:22.721]                 NAMES <- toupper(removed)
[17:29:22.721]                 for (kk in seq_along(NAMES)) {
[17:29:22.721]                   name <- removed[[kk]]
[17:29:22.721]                   NAME <- NAMES[[kk]]
[17:29:22.721]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:22.721]                     next
[17:29:22.721]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:22.721]                 }
[17:29:22.721]                 if (length(args) > 0) 
[17:29:22.721]                   base::do.call(base::Sys.setenv, args = args)
[17:29:22.721]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:22.721]             }
[17:29:22.721]             else {
[17:29:22.721]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:22.721]             }
[17:29:22.721]             {
[17:29:22.721]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:22.721]                   0L) {
[17:29:22.721]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:22.721]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:22.721]                   base::options(opts)
[17:29:22.721]                 }
[17:29:22.721]                 {
[17:29:22.721]                   {
[17:29:22.721]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:22.721]                     NULL
[17:29:22.721]                   }
[17:29:22.721]                   options(future.plan = NULL)
[17:29:22.721]                   if (is.na(NA_character_)) 
[17:29:22.721]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:22.721]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:22.721]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:22.721]                     .init = FALSE)
[17:29:22.721]                 }
[17:29:22.721]             }
[17:29:22.721]         }
[17:29:22.721]     })
[17:29:22.721]     if (TRUE) {
[17:29:22.721]         base::sink(type = "output", split = FALSE)
[17:29:22.721]         if (TRUE) {
[17:29:22.721]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:22.721]         }
[17:29:22.721]         else {
[17:29:22.721]             ...future.result["stdout"] <- base::list(NULL)
[17:29:22.721]         }
[17:29:22.721]         base::close(...future.stdout)
[17:29:22.721]         ...future.stdout <- NULL
[17:29:22.721]     }
[17:29:22.721]     ...future.result$conditions <- ...future.conditions
[17:29:22.721]     ...future.result$finished <- base::Sys.time()
[17:29:22.721]     ...future.result
[17:29:22.721] }
[17:29:22.729] MultisessionFuture started
[17:29:22.729] - Launch lazy future ... done
[17:29:22.729] run() for 'MultisessionFuture' ... done
[17:29:23.264] receiveMessageFromWorker() for ClusterFuture ...
[17:29:23.265] - Validating connection of MultisessionFuture
[17:29:23.265] - received message: FutureResult
[17:29:23.266] - Received FutureResult
[17:29:23.266] - Erased future from FutureRegistry
[17:29:23.266] result() for ClusterFuture ...
[17:29:23.266] - result already collected: FutureResult
[17:29:23.267] result() for ClusterFuture ... done
[17:29:23.267] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:23.267] resolve() on list ...
[17:29:23.268]  recursive: Inf
[17:29:23.268]  length: 2
[17:29:23.268]  elements: 'a', 'b'
[17:29:23.269]  length: 1 (resolved future 1)
[17:29:23.269]  length: 0 (resolved future 2)
[17:29:23.269] resolve() on list ... DONE
[17:29:23.269] A MultisessionFuture was resolved (and resolved itself)
[17:29:23.270] getGlobalsAndPackages() ...
[17:29:23.270] Searching for globals...
[17:29:23.272] - globals found: [3] '{', 'Sys.sleep', 'list'
[17:29:23.273] Searching for globals ... DONE
[17:29:23.273] Resolving globals: FALSE
[17:29:23.274] 
[17:29:23.274] 
[17:29:23.274] getGlobalsAndPackages() ... DONE
[17:29:23.275] run() for 'Future' ...
[17:29:23.275] - state: 'created'
[17:29:23.276] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:23.294] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:23.294] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:23.295]   - Field: 'node'
[17:29:23.295]   - Field: 'label'
[17:29:23.295]   - Field: 'local'
[17:29:23.295]   - Field: 'owner'
[17:29:23.295]   - Field: 'envir'
[17:29:23.296]   - Field: 'workers'
[17:29:23.296]   - Field: 'packages'
[17:29:23.296]   - Field: 'gc'
[17:29:23.296]   - Field: 'conditions'
[17:29:23.296]   - Field: 'persistent'
[17:29:23.296]   - Field: 'expr'
[17:29:23.297]   - Field: 'uuid'
[17:29:23.297]   - Field: 'seed'
[17:29:23.297]   - Field: 'version'
[17:29:23.297]   - Field: 'result'
[17:29:23.297]   - Field: 'asynchronous'
[17:29:23.297]   - Field: 'calls'
[17:29:23.298]   - Field: 'globals'
[17:29:23.298]   - Field: 'stdout'
[17:29:23.298]   - Field: 'earlySignal'
[17:29:23.298]   - Field: 'lazy'
[17:29:23.298]   - Field: 'state'
[17:29:23.299] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:23.299] - Launch lazy future ...
[17:29:23.299] Packages needed by the future expression (n = 0): <none>
[17:29:23.299] Packages needed by future strategies (n = 0): <none>
[17:29:23.300] {
[17:29:23.300]     {
[17:29:23.300]         {
[17:29:23.300]             ...future.startTime <- base::Sys.time()
[17:29:23.300]             {
[17:29:23.300]                 {
[17:29:23.300]                   {
[17:29:23.300]                     {
[17:29:23.300]                       base::local({
[17:29:23.300]                         has_future <- base::requireNamespace("future", 
[17:29:23.300]                           quietly = TRUE)
[17:29:23.300]                         if (has_future) {
[17:29:23.300]                           ns <- base::getNamespace("future")
[17:29:23.300]                           version <- ns[[".package"]][["version"]]
[17:29:23.300]                           if (is.null(version)) 
[17:29:23.300]                             version <- utils::packageVersion("future")
[17:29:23.300]                         }
[17:29:23.300]                         else {
[17:29:23.300]                           version <- NULL
[17:29:23.300]                         }
[17:29:23.300]                         if (!has_future || version < "1.8.0") {
[17:29:23.300]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:23.300]                             "", base::R.version$version.string), 
[17:29:23.300]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:23.300]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:23.300]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:23.300]                               "release", "version")], collapse = " "), 
[17:29:23.300]                             hostname = base::Sys.info()[["nodename"]])
[17:29:23.300]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:23.300]                             info)
[17:29:23.300]                           info <- base::paste(info, collapse = "; ")
[17:29:23.300]                           if (!has_future) {
[17:29:23.300]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:23.300]                               info)
[17:29:23.300]                           }
[17:29:23.300]                           else {
[17:29:23.300]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:23.300]                               info, version)
[17:29:23.300]                           }
[17:29:23.300]                           base::stop(msg)
[17:29:23.300]                         }
[17:29:23.300]                       })
[17:29:23.300]                     }
[17:29:23.300]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:23.300]                     base::options(mc.cores = 1L)
[17:29:23.300]                   }
[17:29:23.300]                   ...future.strategy.old <- future::plan("list")
[17:29:23.300]                   options(future.plan = NULL)
[17:29:23.300]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:23.300]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:23.300]                 }
[17:29:23.300]                 ...future.workdir <- getwd()
[17:29:23.300]             }
[17:29:23.300]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:23.300]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:23.300]         }
[17:29:23.300]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:23.300]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:23.300]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:23.300]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:23.300]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:23.300]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:23.300]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:23.300]             base::names(...future.oldOptions))
[17:29:23.300]     }
[17:29:23.300]     if (FALSE) {
[17:29:23.300]     }
[17:29:23.300]     else {
[17:29:23.300]         if (TRUE) {
[17:29:23.300]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:23.300]                 open = "w")
[17:29:23.300]         }
[17:29:23.300]         else {
[17:29:23.300]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:23.300]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:23.300]         }
[17:29:23.300]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:23.300]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:23.300]             base::sink(type = "output", split = FALSE)
[17:29:23.300]             base::close(...future.stdout)
[17:29:23.300]         }, add = TRUE)
[17:29:23.300]     }
[17:29:23.300]     ...future.frame <- base::sys.nframe()
[17:29:23.300]     ...future.conditions <- base::list()
[17:29:23.300]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:23.300]     if (FALSE) {
[17:29:23.300]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:23.300]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:23.300]     }
[17:29:23.300]     ...future.result <- base::tryCatch({
[17:29:23.300]         base::withCallingHandlers({
[17:29:23.300]             ...future.value <- base::withVisible(base::local({
[17:29:23.300]                 ...future.makeSendCondition <- base::local({
[17:29:23.300]                   sendCondition <- NULL
[17:29:23.300]                   function(frame = 1L) {
[17:29:23.300]                     if (is.function(sendCondition)) 
[17:29:23.300]                       return(sendCondition)
[17:29:23.300]                     ns <- getNamespace("parallel")
[17:29:23.300]                     if (exists("sendData", mode = "function", 
[17:29:23.300]                       envir = ns)) {
[17:29:23.300]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:23.300]                         envir = ns)
[17:29:23.300]                       envir <- sys.frame(frame)
[17:29:23.300]                       master <- NULL
[17:29:23.300]                       while (!identical(envir, .GlobalEnv) && 
[17:29:23.300]                         !identical(envir, emptyenv())) {
[17:29:23.300]                         if (exists("master", mode = "list", envir = envir, 
[17:29:23.300]                           inherits = FALSE)) {
[17:29:23.300]                           master <- get("master", mode = "list", 
[17:29:23.300]                             envir = envir, inherits = FALSE)
[17:29:23.300]                           if (inherits(master, c("SOCKnode", 
[17:29:23.300]                             "SOCK0node"))) {
[17:29:23.300]                             sendCondition <<- function(cond) {
[17:29:23.300]                               data <- list(type = "VALUE", value = cond, 
[17:29:23.300]                                 success = TRUE)
[17:29:23.300]                               parallel_sendData(master, data)
[17:29:23.300]                             }
[17:29:23.300]                             return(sendCondition)
[17:29:23.300]                           }
[17:29:23.300]                         }
[17:29:23.300]                         frame <- frame + 1L
[17:29:23.300]                         envir <- sys.frame(frame)
[17:29:23.300]                       }
[17:29:23.300]                     }
[17:29:23.300]                     sendCondition <<- function(cond) NULL
[17:29:23.300]                   }
[17:29:23.300]                 })
[17:29:23.300]                 withCallingHandlers({
[17:29:23.300]                   {
[17:29:23.300]                     Sys.sleep(0.5)
[17:29:23.300]                     list(a = 1, b = 42L)
[17:29:23.300]                   }
[17:29:23.300]                 }, immediateCondition = function(cond) {
[17:29:23.300]                   sendCondition <- ...future.makeSendCondition()
[17:29:23.300]                   sendCondition(cond)
[17:29:23.300]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:23.300]                   {
[17:29:23.300]                     inherits <- base::inherits
[17:29:23.300]                     invokeRestart <- base::invokeRestart
[17:29:23.300]                     is.null <- base::is.null
[17:29:23.300]                     muffled <- FALSE
[17:29:23.300]                     if (inherits(cond, "message")) {
[17:29:23.300]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:23.300]                       if (muffled) 
[17:29:23.300]                         invokeRestart("muffleMessage")
[17:29:23.300]                     }
[17:29:23.300]                     else if (inherits(cond, "warning")) {
[17:29:23.300]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:23.300]                       if (muffled) 
[17:29:23.300]                         invokeRestart("muffleWarning")
[17:29:23.300]                     }
[17:29:23.300]                     else if (inherits(cond, "condition")) {
[17:29:23.300]                       if (!is.null(pattern)) {
[17:29:23.300]                         computeRestarts <- base::computeRestarts
[17:29:23.300]                         grepl <- base::grepl
[17:29:23.300]                         restarts <- computeRestarts(cond)
[17:29:23.300]                         for (restart in restarts) {
[17:29:23.300]                           name <- restart$name
[17:29:23.300]                           if (is.null(name)) 
[17:29:23.300]                             next
[17:29:23.300]                           if (!grepl(pattern, name)) 
[17:29:23.300]                             next
[17:29:23.300]                           invokeRestart(restart)
[17:29:23.300]                           muffled <- TRUE
[17:29:23.300]                           break
[17:29:23.300]                         }
[17:29:23.300]                       }
[17:29:23.300]                     }
[17:29:23.300]                     invisible(muffled)
[17:29:23.300]                   }
[17:29:23.300]                   muffleCondition(cond)
[17:29:23.300]                 })
[17:29:23.300]             }))
[17:29:23.300]             future::FutureResult(value = ...future.value$value, 
[17:29:23.300]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:23.300]                   ...future.rng), globalenv = if (FALSE) 
[17:29:23.300]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:23.300]                     ...future.globalenv.names))
[17:29:23.300]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:23.300]         }, condition = base::local({
[17:29:23.300]             c <- base::c
[17:29:23.300]             inherits <- base::inherits
[17:29:23.300]             invokeRestart <- base::invokeRestart
[17:29:23.300]             length <- base::length
[17:29:23.300]             list <- base::list
[17:29:23.300]             seq.int <- base::seq.int
[17:29:23.300]             signalCondition <- base::signalCondition
[17:29:23.300]             sys.calls <- base::sys.calls
[17:29:23.300]             `[[` <- base::`[[`
[17:29:23.300]             `+` <- base::`+`
[17:29:23.300]             `<<-` <- base::`<<-`
[17:29:23.300]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:23.300]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:23.300]                   3L)]
[17:29:23.300]             }
[17:29:23.300]             function(cond) {
[17:29:23.300]                 is_error <- inherits(cond, "error")
[17:29:23.300]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:23.300]                   NULL)
[17:29:23.300]                 if (is_error) {
[17:29:23.300]                   sessionInformation <- function() {
[17:29:23.300]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:23.300]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:23.300]                       search = base::search(), system = base::Sys.info())
[17:29:23.300]                   }
[17:29:23.300]                   ...future.conditions[[length(...future.conditions) + 
[17:29:23.300]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:23.300]                     cond$call), session = sessionInformation(), 
[17:29:23.300]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:23.300]                   signalCondition(cond)
[17:29:23.300]                 }
[17:29:23.300]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:23.300]                 "immediateCondition"))) {
[17:29:23.300]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:23.300]                   ...future.conditions[[length(...future.conditions) + 
[17:29:23.300]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:23.300]                   if (TRUE && !signal) {
[17:29:23.300]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:23.300]                     {
[17:29:23.300]                       inherits <- base::inherits
[17:29:23.300]                       invokeRestart <- base::invokeRestart
[17:29:23.300]                       is.null <- base::is.null
[17:29:23.300]                       muffled <- FALSE
[17:29:23.300]                       if (inherits(cond, "message")) {
[17:29:23.300]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:23.300]                         if (muffled) 
[17:29:23.300]                           invokeRestart("muffleMessage")
[17:29:23.300]                       }
[17:29:23.300]                       else if (inherits(cond, "warning")) {
[17:29:23.300]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:23.300]                         if (muffled) 
[17:29:23.300]                           invokeRestart("muffleWarning")
[17:29:23.300]                       }
[17:29:23.300]                       else if (inherits(cond, "condition")) {
[17:29:23.300]                         if (!is.null(pattern)) {
[17:29:23.300]                           computeRestarts <- base::computeRestarts
[17:29:23.300]                           grepl <- base::grepl
[17:29:23.300]                           restarts <- computeRestarts(cond)
[17:29:23.300]                           for (restart in restarts) {
[17:29:23.300]                             name <- restart$name
[17:29:23.300]                             if (is.null(name)) 
[17:29:23.300]                               next
[17:29:23.300]                             if (!grepl(pattern, name)) 
[17:29:23.300]                               next
[17:29:23.300]                             invokeRestart(restart)
[17:29:23.300]                             muffled <- TRUE
[17:29:23.300]                             break
[17:29:23.300]                           }
[17:29:23.300]                         }
[17:29:23.300]                       }
[17:29:23.300]                       invisible(muffled)
[17:29:23.300]                     }
[17:29:23.300]                     muffleCondition(cond, pattern = "^muffle")
[17:29:23.300]                   }
[17:29:23.300]                 }
[17:29:23.300]                 else {
[17:29:23.300]                   if (TRUE) {
[17:29:23.300]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:23.300]                     {
[17:29:23.300]                       inherits <- base::inherits
[17:29:23.300]                       invokeRestart <- base::invokeRestart
[17:29:23.300]                       is.null <- base::is.null
[17:29:23.300]                       muffled <- FALSE
[17:29:23.300]                       if (inherits(cond, "message")) {
[17:29:23.300]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:23.300]                         if (muffled) 
[17:29:23.300]                           invokeRestart("muffleMessage")
[17:29:23.300]                       }
[17:29:23.300]                       else if (inherits(cond, "warning")) {
[17:29:23.300]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:23.300]                         if (muffled) 
[17:29:23.300]                           invokeRestart("muffleWarning")
[17:29:23.300]                       }
[17:29:23.300]                       else if (inherits(cond, "condition")) {
[17:29:23.300]                         if (!is.null(pattern)) {
[17:29:23.300]                           computeRestarts <- base::computeRestarts
[17:29:23.300]                           grepl <- base::grepl
[17:29:23.300]                           restarts <- computeRestarts(cond)
[17:29:23.300]                           for (restart in restarts) {
[17:29:23.300]                             name <- restart$name
[17:29:23.300]                             if (is.null(name)) 
[17:29:23.300]                               next
[17:29:23.300]                             if (!grepl(pattern, name)) 
[17:29:23.300]                               next
[17:29:23.300]                             invokeRestart(restart)
[17:29:23.300]                             muffled <- TRUE
[17:29:23.300]                             break
[17:29:23.300]                           }
[17:29:23.300]                         }
[17:29:23.300]                       }
[17:29:23.300]                       invisible(muffled)
[17:29:23.300]                     }
[17:29:23.300]                     muffleCondition(cond, pattern = "^muffle")
[17:29:23.300]                   }
[17:29:23.300]                 }
[17:29:23.300]             }
[17:29:23.300]         }))
[17:29:23.300]     }, error = function(ex) {
[17:29:23.300]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:23.300]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:23.300]                 ...future.rng), started = ...future.startTime, 
[17:29:23.300]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:23.300]             version = "1.8"), class = "FutureResult")
[17:29:23.300]     }, finally = {
[17:29:23.300]         if (!identical(...future.workdir, getwd())) 
[17:29:23.300]             setwd(...future.workdir)
[17:29:23.300]         {
[17:29:23.300]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:23.300]                 ...future.oldOptions$nwarnings <- NULL
[17:29:23.300]             }
[17:29:23.300]             base::options(...future.oldOptions)
[17:29:23.300]             if (.Platform$OS.type == "windows") {
[17:29:23.300]                 old_names <- names(...future.oldEnvVars)
[17:29:23.300]                 envs <- base::Sys.getenv()
[17:29:23.300]                 names <- names(envs)
[17:29:23.300]                 common <- intersect(names, old_names)
[17:29:23.300]                 added <- setdiff(names, old_names)
[17:29:23.300]                 removed <- setdiff(old_names, names)
[17:29:23.300]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:23.300]                   envs[common]]
[17:29:23.300]                 NAMES <- toupper(changed)
[17:29:23.300]                 args <- list()
[17:29:23.300]                 for (kk in seq_along(NAMES)) {
[17:29:23.300]                   name <- changed[[kk]]
[17:29:23.300]                   NAME <- NAMES[[kk]]
[17:29:23.300]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:23.300]                     next
[17:29:23.300]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:23.300]                 }
[17:29:23.300]                 NAMES <- toupper(added)
[17:29:23.300]                 for (kk in seq_along(NAMES)) {
[17:29:23.300]                   name <- added[[kk]]
[17:29:23.300]                   NAME <- NAMES[[kk]]
[17:29:23.300]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:23.300]                     next
[17:29:23.300]                   args[[name]] <- ""
[17:29:23.300]                 }
[17:29:23.300]                 NAMES <- toupper(removed)
[17:29:23.300]                 for (kk in seq_along(NAMES)) {
[17:29:23.300]                   name <- removed[[kk]]
[17:29:23.300]                   NAME <- NAMES[[kk]]
[17:29:23.300]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:23.300]                     next
[17:29:23.300]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:23.300]                 }
[17:29:23.300]                 if (length(args) > 0) 
[17:29:23.300]                   base::do.call(base::Sys.setenv, args = args)
[17:29:23.300]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:23.300]             }
[17:29:23.300]             else {
[17:29:23.300]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:23.300]             }
[17:29:23.300]             {
[17:29:23.300]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:23.300]                   0L) {
[17:29:23.300]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:23.300]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:23.300]                   base::options(opts)
[17:29:23.300]                 }
[17:29:23.300]                 {
[17:29:23.300]                   {
[17:29:23.300]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:23.300]                     NULL
[17:29:23.300]                   }
[17:29:23.300]                   options(future.plan = NULL)
[17:29:23.300]                   if (is.na(NA_character_)) 
[17:29:23.300]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:23.300]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:23.300]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:23.300]                     .init = FALSE)
[17:29:23.300]                 }
[17:29:23.300]             }
[17:29:23.300]         }
[17:29:23.300]     })
[17:29:23.300]     if (TRUE) {
[17:29:23.300]         base::sink(type = "output", split = FALSE)
[17:29:23.300]         if (TRUE) {
[17:29:23.300]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:23.300]         }
[17:29:23.300]         else {
[17:29:23.300]             ...future.result["stdout"] <- base::list(NULL)
[17:29:23.300]         }
[17:29:23.300]         base::close(...future.stdout)
[17:29:23.300]         ...future.stdout <- NULL
[17:29:23.300]     }
[17:29:23.300]     ...future.result$conditions <- ...future.conditions
[17:29:23.300]     ...future.result$finished <- base::Sys.time()
[17:29:23.300]     ...future.result
[17:29:23.300] }
[17:29:23.309] MultisessionFuture started
[17:29:23.309] - Launch lazy future ... done
[17:29:23.309] run() for 'MultisessionFuture' ... done
[17:29:23.840] receiveMessageFromWorker() for ClusterFuture ...
[17:29:23.841] - Validating connection of MultisessionFuture
[17:29:23.841] - received message: FutureResult
[17:29:23.842] - Received FutureResult
[17:29:23.842] - Erased future from FutureRegistry
[17:29:23.842] result() for ClusterFuture ...
[17:29:23.843] - result already collected: FutureResult
[17:29:23.843] result() for ClusterFuture ... done
[17:29:23.843] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:23.844] resolve() on list ...
[17:29:23.844]  recursive: Inf
[17:29:23.844]  length: 2
[17:29:23.844]  elements: 'a', 'b'
[17:29:23.845]  length: 1 (resolved future 1)
[17:29:23.845]  length: 0 (resolved future 2)
[17:29:23.845] resolve() on list ... DONE
[17:29:23.845] A MultisessionFuture was resolved (and resolved itself)
- w/ exception ...
[17:29:23.846] getGlobalsAndPackages() ...
[17:29:23.846] Searching for globals...
[17:29:23.847] - globals found: [2] 'list', 'stop'
[17:29:23.848] Searching for globals ... DONE
[17:29:23.848] Resolving globals: FALSE
[17:29:23.849] 
[17:29:23.849] 
[17:29:23.849] getGlobalsAndPackages() ... DONE
[17:29:23.850] run() for 'Future' ...
[17:29:23.850] - state: 'created'
[17:29:23.850] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:23.870] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:23.871] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:23.871]   - Field: 'node'
[17:29:23.871]   - Field: 'label'
[17:29:23.872]   - Field: 'local'
[17:29:23.872]   - Field: 'owner'
[17:29:23.872]   - Field: 'envir'
[17:29:23.873]   - Field: 'workers'
[17:29:23.873]   - Field: 'packages'
[17:29:23.873]   - Field: 'gc'
[17:29:23.874]   - Field: 'conditions'
[17:29:23.874]   - Field: 'persistent'
[17:29:23.874]   - Field: 'expr'
[17:29:23.875]   - Field: 'uuid'
[17:29:23.875]   - Field: 'seed'
[17:29:23.875]   - Field: 'version'
[17:29:23.876]   - Field: 'result'
[17:29:23.876]   - Field: 'asynchronous'
[17:29:23.876]   - Field: 'calls'
[17:29:23.877]   - Field: 'globals'
[17:29:23.877]   - Field: 'stdout'
[17:29:23.877]   - Field: 'earlySignal'
[17:29:23.878]   - Field: 'lazy'
[17:29:23.878]   - Field: 'state'
[17:29:23.878] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:23.878] - Launch lazy future ...
[17:29:23.879] Packages needed by the future expression (n = 0): <none>
[17:29:23.879] Packages needed by future strategies (n = 0): <none>
[17:29:23.880] {
[17:29:23.880]     {
[17:29:23.880]         {
[17:29:23.880]             ...future.startTime <- base::Sys.time()
[17:29:23.880]             {
[17:29:23.880]                 {
[17:29:23.880]                   {
[17:29:23.880]                     {
[17:29:23.880]                       base::local({
[17:29:23.880]                         has_future <- base::requireNamespace("future", 
[17:29:23.880]                           quietly = TRUE)
[17:29:23.880]                         if (has_future) {
[17:29:23.880]                           ns <- base::getNamespace("future")
[17:29:23.880]                           version <- ns[[".package"]][["version"]]
[17:29:23.880]                           if (is.null(version)) 
[17:29:23.880]                             version <- utils::packageVersion("future")
[17:29:23.880]                         }
[17:29:23.880]                         else {
[17:29:23.880]                           version <- NULL
[17:29:23.880]                         }
[17:29:23.880]                         if (!has_future || version < "1.8.0") {
[17:29:23.880]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:23.880]                             "", base::R.version$version.string), 
[17:29:23.880]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:23.880]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:23.880]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:23.880]                               "release", "version")], collapse = " "), 
[17:29:23.880]                             hostname = base::Sys.info()[["nodename"]])
[17:29:23.880]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:23.880]                             info)
[17:29:23.880]                           info <- base::paste(info, collapse = "; ")
[17:29:23.880]                           if (!has_future) {
[17:29:23.880]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:23.880]                               info)
[17:29:23.880]                           }
[17:29:23.880]                           else {
[17:29:23.880]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:23.880]                               info, version)
[17:29:23.880]                           }
[17:29:23.880]                           base::stop(msg)
[17:29:23.880]                         }
[17:29:23.880]                       })
[17:29:23.880]                     }
[17:29:23.880]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:23.880]                     base::options(mc.cores = 1L)
[17:29:23.880]                   }
[17:29:23.880]                   ...future.strategy.old <- future::plan("list")
[17:29:23.880]                   options(future.plan = NULL)
[17:29:23.880]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:23.880]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:23.880]                 }
[17:29:23.880]                 ...future.workdir <- getwd()
[17:29:23.880]             }
[17:29:23.880]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:23.880]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:23.880]         }
[17:29:23.880]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:23.880]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:23.880]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:23.880]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:23.880]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:23.880]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:23.880]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:23.880]             base::names(...future.oldOptions))
[17:29:23.880]     }
[17:29:23.880]     if (FALSE) {
[17:29:23.880]     }
[17:29:23.880]     else {
[17:29:23.880]         if (TRUE) {
[17:29:23.880]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:23.880]                 open = "w")
[17:29:23.880]         }
[17:29:23.880]         else {
[17:29:23.880]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:23.880]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:23.880]         }
[17:29:23.880]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:23.880]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:23.880]             base::sink(type = "output", split = FALSE)
[17:29:23.880]             base::close(...future.stdout)
[17:29:23.880]         }, add = TRUE)
[17:29:23.880]     }
[17:29:23.880]     ...future.frame <- base::sys.nframe()
[17:29:23.880]     ...future.conditions <- base::list()
[17:29:23.880]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:23.880]     if (FALSE) {
[17:29:23.880]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:23.880]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:23.880]     }
[17:29:23.880]     ...future.result <- base::tryCatch({
[17:29:23.880]         base::withCallingHandlers({
[17:29:23.880]             ...future.value <- base::withVisible(base::local({
[17:29:23.880]                 ...future.makeSendCondition <- base::local({
[17:29:23.880]                   sendCondition <- NULL
[17:29:23.880]                   function(frame = 1L) {
[17:29:23.880]                     if (is.function(sendCondition)) 
[17:29:23.880]                       return(sendCondition)
[17:29:23.880]                     ns <- getNamespace("parallel")
[17:29:23.880]                     if (exists("sendData", mode = "function", 
[17:29:23.880]                       envir = ns)) {
[17:29:23.880]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:23.880]                         envir = ns)
[17:29:23.880]                       envir <- sys.frame(frame)
[17:29:23.880]                       master <- NULL
[17:29:23.880]                       while (!identical(envir, .GlobalEnv) && 
[17:29:23.880]                         !identical(envir, emptyenv())) {
[17:29:23.880]                         if (exists("master", mode = "list", envir = envir, 
[17:29:23.880]                           inherits = FALSE)) {
[17:29:23.880]                           master <- get("master", mode = "list", 
[17:29:23.880]                             envir = envir, inherits = FALSE)
[17:29:23.880]                           if (inherits(master, c("SOCKnode", 
[17:29:23.880]                             "SOCK0node"))) {
[17:29:23.880]                             sendCondition <<- function(cond) {
[17:29:23.880]                               data <- list(type = "VALUE", value = cond, 
[17:29:23.880]                                 success = TRUE)
[17:29:23.880]                               parallel_sendData(master, data)
[17:29:23.880]                             }
[17:29:23.880]                             return(sendCondition)
[17:29:23.880]                           }
[17:29:23.880]                         }
[17:29:23.880]                         frame <- frame + 1L
[17:29:23.880]                         envir <- sys.frame(frame)
[17:29:23.880]                       }
[17:29:23.880]                     }
[17:29:23.880]                     sendCondition <<- function(cond) NULL
[17:29:23.880]                   }
[17:29:23.880]                 })
[17:29:23.880]                 withCallingHandlers({
[17:29:23.880]                   list(a = 1, b = 42L, c = stop("Nah!"))
[17:29:23.880]                 }, immediateCondition = function(cond) {
[17:29:23.880]                   sendCondition <- ...future.makeSendCondition()
[17:29:23.880]                   sendCondition(cond)
[17:29:23.880]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:23.880]                   {
[17:29:23.880]                     inherits <- base::inherits
[17:29:23.880]                     invokeRestart <- base::invokeRestart
[17:29:23.880]                     is.null <- base::is.null
[17:29:23.880]                     muffled <- FALSE
[17:29:23.880]                     if (inherits(cond, "message")) {
[17:29:23.880]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:23.880]                       if (muffled) 
[17:29:23.880]                         invokeRestart("muffleMessage")
[17:29:23.880]                     }
[17:29:23.880]                     else if (inherits(cond, "warning")) {
[17:29:23.880]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:23.880]                       if (muffled) 
[17:29:23.880]                         invokeRestart("muffleWarning")
[17:29:23.880]                     }
[17:29:23.880]                     else if (inherits(cond, "condition")) {
[17:29:23.880]                       if (!is.null(pattern)) {
[17:29:23.880]                         computeRestarts <- base::computeRestarts
[17:29:23.880]                         grepl <- base::grepl
[17:29:23.880]                         restarts <- computeRestarts(cond)
[17:29:23.880]                         for (restart in restarts) {
[17:29:23.880]                           name <- restart$name
[17:29:23.880]                           if (is.null(name)) 
[17:29:23.880]                             next
[17:29:23.880]                           if (!grepl(pattern, name)) 
[17:29:23.880]                             next
[17:29:23.880]                           invokeRestart(restart)
[17:29:23.880]                           muffled <- TRUE
[17:29:23.880]                           break
[17:29:23.880]                         }
[17:29:23.880]                       }
[17:29:23.880]                     }
[17:29:23.880]                     invisible(muffled)
[17:29:23.880]                   }
[17:29:23.880]                   muffleCondition(cond)
[17:29:23.880]                 })
[17:29:23.880]             }))
[17:29:23.880]             future::FutureResult(value = ...future.value$value, 
[17:29:23.880]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:23.880]                   ...future.rng), globalenv = if (FALSE) 
[17:29:23.880]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:23.880]                     ...future.globalenv.names))
[17:29:23.880]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:23.880]         }, condition = base::local({
[17:29:23.880]             c <- base::c
[17:29:23.880]             inherits <- base::inherits
[17:29:23.880]             invokeRestart <- base::invokeRestart
[17:29:23.880]             length <- base::length
[17:29:23.880]             list <- base::list
[17:29:23.880]             seq.int <- base::seq.int
[17:29:23.880]             signalCondition <- base::signalCondition
[17:29:23.880]             sys.calls <- base::sys.calls
[17:29:23.880]             `[[` <- base::`[[`
[17:29:23.880]             `+` <- base::`+`
[17:29:23.880]             `<<-` <- base::`<<-`
[17:29:23.880]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:23.880]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:23.880]                   3L)]
[17:29:23.880]             }
[17:29:23.880]             function(cond) {
[17:29:23.880]                 is_error <- inherits(cond, "error")
[17:29:23.880]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:23.880]                   NULL)
[17:29:23.880]                 if (is_error) {
[17:29:23.880]                   sessionInformation <- function() {
[17:29:23.880]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:23.880]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:23.880]                       search = base::search(), system = base::Sys.info())
[17:29:23.880]                   }
[17:29:23.880]                   ...future.conditions[[length(...future.conditions) + 
[17:29:23.880]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:23.880]                     cond$call), session = sessionInformation(), 
[17:29:23.880]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:23.880]                   signalCondition(cond)
[17:29:23.880]                 }
[17:29:23.880]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:23.880]                 "immediateCondition"))) {
[17:29:23.880]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:23.880]                   ...future.conditions[[length(...future.conditions) + 
[17:29:23.880]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:23.880]                   if (TRUE && !signal) {
[17:29:23.880]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:23.880]                     {
[17:29:23.880]                       inherits <- base::inherits
[17:29:23.880]                       invokeRestart <- base::invokeRestart
[17:29:23.880]                       is.null <- base::is.null
[17:29:23.880]                       muffled <- FALSE
[17:29:23.880]                       if (inherits(cond, "message")) {
[17:29:23.880]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:23.880]                         if (muffled) 
[17:29:23.880]                           invokeRestart("muffleMessage")
[17:29:23.880]                       }
[17:29:23.880]                       else if (inherits(cond, "warning")) {
[17:29:23.880]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:23.880]                         if (muffled) 
[17:29:23.880]                           invokeRestart("muffleWarning")
[17:29:23.880]                       }
[17:29:23.880]                       else if (inherits(cond, "condition")) {
[17:29:23.880]                         if (!is.null(pattern)) {
[17:29:23.880]                           computeRestarts <- base::computeRestarts
[17:29:23.880]                           grepl <- base::grepl
[17:29:23.880]                           restarts <- computeRestarts(cond)
[17:29:23.880]                           for (restart in restarts) {
[17:29:23.880]                             name <- restart$name
[17:29:23.880]                             if (is.null(name)) 
[17:29:23.880]                               next
[17:29:23.880]                             if (!grepl(pattern, name)) 
[17:29:23.880]                               next
[17:29:23.880]                             invokeRestart(restart)
[17:29:23.880]                             muffled <- TRUE
[17:29:23.880]                             break
[17:29:23.880]                           }
[17:29:23.880]                         }
[17:29:23.880]                       }
[17:29:23.880]                       invisible(muffled)
[17:29:23.880]                     }
[17:29:23.880]                     muffleCondition(cond, pattern = "^muffle")
[17:29:23.880]                   }
[17:29:23.880]                 }
[17:29:23.880]                 else {
[17:29:23.880]                   if (TRUE) {
[17:29:23.880]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:23.880]                     {
[17:29:23.880]                       inherits <- base::inherits
[17:29:23.880]                       invokeRestart <- base::invokeRestart
[17:29:23.880]                       is.null <- base::is.null
[17:29:23.880]                       muffled <- FALSE
[17:29:23.880]                       if (inherits(cond, "message")) {
[17:29:23.880]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:23.880]                         if (muffled) 
[17:29:23.880]                           invokeRestart("muffleMessage")
[17:29:23.880]                       }
[17:29:23.880]                       else if (inherits(cond, "warning")) {
[17:29:23.880]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:23.880]                         if (muffled) 
[17:29:23.880]                           invokeRestart("muffleWarning")
[17:29:23.880]                       }
[17:29:23.880]                       else if (inherits(cond, "condition")) {
[17:29:23.880]                         if (!is.null(pattern)) {
[17:29:23.880]                           computeRestarts <- base::computeRestarts
[17:29:23.880]                           grepl <- base::grepl
[17:29:23.880]                           restarts <- computeRestarts(cond)
[17:29:23.880]                           for (restart in restarts) {
[17:29:23.880]                             name <- restart$name
[17:29:23.880]                             if (is.null(name)) 
[17:29:23.880]                               next
[17:29:23.880]                             if (!grepl(pattern, name)) 
[17:29:23.880]                               next
[17:29:23.880]                             invokeRestart(restart)
[17:29:23.880]                             muffled <- TRUE
[17:29:23.880]                             break
[17:29:23.880]                           }
[17:29:23.880]                         }
[17:29:23.880]                       }
[17:29:23.880]                       invisible(muffled)
[17:29:23.880]                     }
[17:29:23.880]                     muffleCondition(cond, pattern = "^muffle")
[17:29:23.880]                   }
[17:29:23.880]                 }
[17:29:23.880]             }
[17:29:23.880]         }))
[17:29:23.880]     }, error = function(ex) {
[17:29:23.880]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:23.880]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:23.880]                 ...future.rng), started = ...future.startTime, 
[17:29:23.880]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:23.880]             version = "1.8"), class = "FutureResult")
[17:29:23.880]     }, finally = {
[17:29:23.880]         if (!identical(...future.workdir, getwd())) 
[17:29:23.880]             setwd(...future.workdir)
[17:29:23.880]         {
[17:29:23.880]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:23.880]                 ...future.oldOptions$nwarnings <- NULL
[17:29:23.880]             }
[17:29:23.880]             base::options(...future.oldOptions)
[17:29:23.880]             if (.Platform$OS.type == "windows") {
[17:29:23.880]                 old_names <- names(...future.oldEnvVars)
[17:29:23.880]                 envs <- base::Sys.getenv()
[17:29:23.880]                 names <- names(envs)
[17:29:23.880]                 common <- intersect(names, old_names)
[17:29:23.880]                 added <- setdiff(names, old_names)
[17:29:23.880]                 removed <- setdiff(old_names, names)
[17:29:23.880]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:23.880]                   envs[common]]
[17:29:23.880]                 NAMES <- toupper(changed)
[17:29:23.880]                 args <- list()
[17:29:23.880]                 for (kk in seq_along(NAMES)) {
[17:29:23.880]                   name <- changed[[kk]]
[17:29:23.880]                   NAME <- NAMES[[kk]]
[17:29:23.880]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:23.880]                     next
[17:29:23.880]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:23.880]                 }
[17:29:23.880]                 NAMES <- toupper(added)
[17:29:23.880]                 for (kk in seq_along(NAMES)) {
[17:29:23.880]                   name <- added[[kk]]
[17:29:23.880]                   NAME <- NAMES[[kk]]
[17:29:23.880]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:23.880]                     next
[17:29:23.880]                   args[[name]] <- ""
[17:29:23.880]                 }
[17:29:23.880]                 NAMES <- toupper(removed)
[17:29:23.880]                 for (kk in seq_along(NAMES)) {
[17:29:23.880]                   name <- removed[[kk]]
[17:29:23.880]                   NAME <- NAMES[[kk]]
[17:29:23.880]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:23.880]                     next
[17:29:23.880]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:23.880]                 }
[17:29:23.880]                 if (length(args) > 0) 
[17:29:23.880]                   base::do.call(base::Sys.setenv, args = args)
[17:29:23.880]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:23.880]             }
[17:29:23.880]             else {
[17:29:23.880]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:23.880]             }
[17:29:23.880]             {
[17:29:23.880]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:23.880]                   0L) {
[17:29:23.880]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:23.880]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:23.880]                   base::options(opts)
[17:29:23.880]                 }
[17:29:23.880]                 {
[17:29:23.880]                   {
[17:29:23.880]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:23.880]                     NULL
[17:29:23.880]                   }
[17:29:23.880]                   options(future.plan = NULL)
[17:29:23.880]                   if (is.na(NA_character_)) 
[17:29:23.880]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:23.880]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:23.880]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:23.880]                     .init = FALSE)
[17:29:23.880]                 }
[17:29:23.880]             }
[17:29:23.880]         }
[17:29:23.880]     })
[17:29:23.880]     if (TRUE) {
[17:29:23.880]         base::sink(type = "output", split = FALSE)
[17:29:23.880]         if (TRUE) {
[17:29:23.880]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:23.880]         }
[17:29:23.880]         else {
[17:29:23.880]             ...future.result["stdout"] <- base::list(NULL)
[17:29:23.880]         }
[17:29:23.880]         base::close(...future.stdout)
[17:29:23.880]         ...future.stdout <- NULL
[17:29:23.880]     }
[17:29:23.880]     ...future.result$conditions <- ...future.conditions
[17:29:23.880]     ...future.result$finished <- base::Sys.time()
[17:29:23.880]     ...future.result
[17:29:23.880] }
[17:29:23.889] MultisessionFuture started
[17:29:23.889] - Launch lazy future ... done
[17:29:23.890] run() for 'MultisessionFuture' ... done
[17:29:23.917] receiveMessageFromWorker() for ClusterFuture ...
[17:29:23.917] - Validating connection of MultisessionFuture
[17:29:23.918] - received message: FutureResult
[17:29:23.919] - Received FutureResult
[17:29:23.919] - Erased future from FutureRegistry
[17:29:23.919] result() for ClusterFuture ...
[17:29:23.920] - result already collected: FutureResult
[17:29:23.920] result() for ClusterFuture ... done
[17:29:23.920] signalConditions() ...
[17:29:23.920]  - include = 'immediateCondition'
[17:29:23.921]  - exclude = 
[17:29:23.921]  - resignal = FALSE
[17:29:23.921]  - Number of conditions: 1
[17:29:23.922] signalConditions() ... done
[17:29:23.922] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:23.922] A MultisessionFuture was resolved (and resolved itself)
[17:29:23.922] getGlobalsAndPackages() ...
[17:29:23.923] Searching for globals...
[17:29:23.924] - globals found: [2] 'list', 'stop'
[17:29:23.924] Searching for globals ... DONE
[17:29:23.925] Resolving globals: FALSE
[17:29:23.925] 
[17:29:23.926] 
[17:29:23.926] getGlobalsAndPackages() ... DONE
[17:29:23.926] run() for 'Future' ...
[17:29:23.927] - state: 'created'
[17:29:23.927] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:23.948] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:23.948] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:23.949]   - Field: 'node'
[17:29:23.949]   - Field: 'label'
[17:29:23.949]   - Field: 'local'
[17:29:23.950]   - Field: 'owner'
[17:29:23.950]   - Field: 'envir'
[17:29:23.950]   - Field: 'workers'
[17:29:23.951]   - Field: 'packages'
[17:29:23.951]   - Field: 'gc'
[17:29:23.951]   - Field: 'conditions'
[17:29:23.952]   - Field: 'persistent'
[17:29:23.952]   - Field: 'expr'
[17:29:23.952]   - Field: 'uuid'
[17:29:23.952]   - Field: 'seed'
[17:29:23.953]   - Field: 'version'
[17:29:23.953]   - Field: 'result'
[17:29:23.953]   - Field: 'asynchronous'
[17:29:23.954]   - Field: 'calls'
[17:29:23.954]   - Field: 'globals'
[17:29:23.954]   - Field: 'stdout'
[17:29:23.954]   - Field: 'earlySignal'
[17:29:23.955]   - Field: 'lazy'
[17:29:23.955]   - Field: 'state'
[17:29:23.955] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:23.955] - Launch lazy future ...
[17:29:23.956] Packages needed by the future expression (n = 0): <none>
[17:29:23.956] Packages needed by future strategies (n = 0): <none>
[17:29:23.957] {
[17:29:23.957]     {
[17:29:23.957]         {
[17:29:23.957]             ...future.startTime <- base::Sys.time()
[17:29:23.957]             {
[17:29:23.957]                 {
[17:29:23.957]                   {
[17:29:23.957]                     {
[17:29:23.957]                       base::local({
[17:29:23.957]                         has_future <- base::requireNamespace("future", 
[17:29:23.957]                           quietly = TRUE)
[17:29:23.957]                         if (has_future) {
[17:29:23.957]                           ns <- base::getNamespace("future")
[17:29:23.957]                           version <- ns[[".package"]][["version"]]
[17:29:23.957]                           if (is.null(version)) 
[17:29:23.957]                             version <- utils::packageVersion("future")
[17:29:23.957]                         }
[17:29:23.957]                         else {
[17:29:23.957]                           version <- NULL
[17:29:23.957]                         }
[17:29:23.957]                         if (!has_future || version < "1.8.0") {
[17:29:23.957]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:23.957]                             "", base::R.version$version.string), 
[17:29:23.957]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:23.957]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:23.957]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:23.957]                               "release", "version")], collapse = " "), 
[17:29:23.957]                             hostname = base::Sys.info()[["nodename"]])
[17:29:23.957]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:23.957]                             info)
[17:29:23.957]                           info <- base::paste(info, collapse = "; ")
[17:29:23.957]                           if (!has_future) {
[17:29:23.957]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:23.957]                               info)
[17:29:23.957]                           }
[17:29:23.957]                           else {
[17:29:23.957]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:23.957]                               info, version)
[17:29:23.957]                           }
[17:29:23.957]                           base::stop(msg)
[17:29:23.957]                         }
[17:29:23.957]                       })
[17:29:23.957]                     }
[17:29:23.957]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:23.957]                     base::options(mc.cores = 1L)
[17:29:23.957]                   }
[17:29:23.957]                   ...future.strategy.old <- future::plan("list")
[17:29:23.957]                   options(future.plan = NULL)
[17:29:23.957]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:23.957]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:23.957]                 }
[17:29:23.957]                 ...future.workdir <- getwd()
[17:29:23.957]             }
[17:29:23.957]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:23.957]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:23.957]         }
[17:29:23.957]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:23.957]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:23.957]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:23.957]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:23.957]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:23.957]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:23.957]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:23.957]             base::names(...future.oldOptions))
[17:29:23.957]     }
[17:29:23.957]     if (FALSE) {
[17:29:23.957]     }
[17:29:23.957]     else {
[17:29:23.957]         if (TRUE) {
[17:29:23.957]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:23.957]                 open = "w")
[17:29:23.957]         }
[17:29:23.957]         else {
[17:29:23.957]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:23.957]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:23.957]         }
[17:29:23.957]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:23.957]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:23.957]             base::sink(type = "output", split = FALSE)
[17:29:23.957]             base::close(...future.stdout)
[17:29:23.957]         }, add = TRUE)
[17:29:23.957]     }
[17:29:23.957]     ...future.frame <- base::sys.nframe()
[17:29:23.957]     ...future.conditions <- base::list()
[17:29:23.957]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:23.957]     if (FALSE) {
[17:29:23.957]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:23.957]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:23.957]     }
[17:29:23.957]     ...future.result <- base::tryCatch({
[17:29:23.957]         base::withCallingHandlers({
[17:29:23.957]             ...future.value <- base::withVisible(base::local({
[17:29:23.957]                 ...future.makeSendCondition <- base::local({
[17:29:23.957]                   sendCondition <- NULL
[17:29:23.957]                   function(frame = 1L) {
[17:29:23.957]                     if (is.function(sendCondition)) 
[17:29:23.957]                       return(sendCondition)
[17:29:23.957]                     ns <- getNamespace("parallel")
[17:29:23.957]                     if (exists("sendData", mode = "function", 
[17:29:23.957]                       envir = ns)) {
[17:29:23.957]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:23.957]                         envir = ns)
[17:29:23.957]                       envir <- sys.frame(frame)
[17:29:23.957]                       master <- NULL
[17:29:23.957]                       while (!identical(envir, .GlobalEnv) && 
[17:29:23.957]                         !identical(envir, emptyenv())) {
[17:29:23.957]                         if (exists("master", mode = "list", envir = envir, 
[17:29:23.957]                           inherits = FALSE)) {
[17:29:23.957]                           master <- get("master", mode = "list", 
[17:29:23.957]                             envir = envir, inherits = FALSE)
[17:29:23.957]                           if (inherits(master, c("SOCKnode", 
[17:29:23.957]                             "SOCK0node"))) {
[17:29:23.957]                             sendCondition <<- function(cond) {
[17:29:23.957]                               data <- list(type = "VALUE", value = cond, 
[17:29:23.957]                                 success = TRUE)
[17:29:23.957]                               parallel_sendData(master, data)
[17:29:23.957]                             }
[17:29:23.957]                             return(sendCondition)
[17:29:23.957]                           }
[17:29:23.957]                         }
[17:29:23.957]                         frame <- frame + 1L
[17:29:23.957]                         envir <- sys.frame(frame)
[17:29:23.957]                       }
[17:29:23.957]                     }
[17:29:23.957]                     sendCondition <<- function(cond) NULL
[17:29:23.957]                   }
[17:29:23.957]                 })
[17:29:23.957]                 withCallingHandlers({
[17:29:23.957]                   list(a = 1, b = 42L, c = stop("Nah!"))
[17:29:23.957]                 }, immediateCondition = function(cond) {
[17:29:23.957]                   sendCondition <- ...future.makeSendCondition()
[17:29:23.957]                   sendCondition(cond)
[17:29:23.957]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:23.957]                   {
[17:29:23.957]                     inherits <- base::inherits
[17:29:23.957]                     invokeRestart <- base::invokeRestart
[17:29:23.957]                     is.null <- base::is.null
[17:29:23.957]                     muffled <- FALSE
[17:29:23.957]                     if (inherits(cond, "message")) {
[17:29:23.957]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:23.957]                       if (muffled) 
[17:29:23.957]                         invokeRestart("muffleMessage")
[17:29:23.957]                     }
[17:29:23.957]                     else if (inherits(cond, "warning")) {
[17:29:23.957]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:23.957]                       if (muffled) 
[17:29:23.957]                         invokeRestart("muffleWarning")
[17:29:23.957]                     }
[17:29:23.957]                     else if (inherits(cond, "condition")) {
[17:29:23.957]                       if (!is.null(pattern)) {
[17:29:23.957]                         computeRestarts <- base::computeRestarts
[17:29:23.957]                         grepl <- base::grepl
[17:29:23.957]                         restarts <- computeRestarts(cond)
[17:29:23.957]                         for (restart in restarts) {
[17:29:23.957]                           name <- restart$name
[17:29:23.957]                           if (is.null(name)) 
[17:29:23.957]                             next
[17:29:23.957]                           if (!grepl(pattern, name)) 
[17:29:23.957]                             next
[17:29:23.957]                           invokeRestart(restart)
[17:29:23.957]                           muffled <- TRUE
[17:29:23.957]                           break
[17:29:23.957]                         }
[17:29:23.957]                       }
[17:29:23.957]                     }
[17:29:23.957]                     invisible(muffled)
[17:29:23.957]                   }
[17:29:23.957]                   muffleCondition(cond)
[17:29:23.957]                 })
[17:29:23.957]             }))
[17:29:23.957]             future::FutureResult(value = ...future.value$value, 
[17:29:23.957]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:23.957]                   ...future.rng), globalenv = if (FALSE) 
[17:29:23.957]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:23.957]                     ...future.globalenv.names))
[17:29:23.957]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:23.957]         }, condition = base::local({
[17:29:23.957]             c <- base::c
[17:29:23.957]             inherits <- base::inherits
[17:29:23.957]             invokeRestart <- base::invokeRestart
[17:29:23.957]             length <- base::length
[17:29:23.957]             list <- base::list
[17:29:23.957]             seq.int <- base::seq.int
[17:29:23.957]             signalCondition <- base::signalCondition
[17:29:23.957]             sys.calls <- base::sys.calls
[17:29:23.957]             `[[` <- base::`[[`
[17:29:23.957]             `+` <- base::`+`
[17:29:23.957]             `<<-` <- base::`<<-`
[17:29:23.957]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:23.957]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:23.957]                   3L)]
[17:29:23.957]             }
[17:29:23.957]             function(cond) {
[17:29:23.957]                 is_error <- inherits(cond, "error")
[17:29:23.957]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:23.957]                   NULL)
[17:29:23.957]                 if (is_error) {
[17:29:23.957]                   sessionInformation <- function() {
[17:29:23.957]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:23.957]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:23.957]                       search = base::search(), system = base::Sys.info())
[17:29:23.957]                   }
[17:29:23.957]                   ...future.conditions[[length(...future.conditions) + 
[17:29:23.957]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:23.957]                     cond$call), session = sessionInformation(), 
[17:29:23.957]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:23.957]                   signalCondition(cond)
[17:29:23.957]                 }
[17:29:23.957]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:23.957]                 "immediateCondition"))) {
[17:29:23.957]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:23.957]                   ...future.conditions[[length(...future.conditions) + 
[17:29:23.957]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:23.957]                   if (TRUE && !signal) {
[17:29:23.957]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:23.957]                     {
[17:29:23.957]                       inherits <- base::inherits
[17:29:23.957]                       invokeRestart <- base::invokeRestart
[17:29:23.957]                       is.null <- base::is.null
[17:29:23.957]                       muffled <- FALSE
[17:29:23.957]                       if (inherits(cond, "message")) {
[17:29:23.957]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:23.957]                         if (muffled) 
[17:29:23.957]                           invokeRestart("muffleMessage")
[17:29:23.957]                       }
[17:29:23.957]                       else if (inherits(cond, "warning")) {
[17:29:23.957]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:23.957]                         if (muffled) 
[17:29:23.957]                           invokeRestart("muffleWarning")
[17:29:23.957]                       }
[17:29:23.957]                       else if (inherits(cond, "condition")) {
[17:29:23.957]                         if (!is.null(pattern)) {
[17:29:23.957]                           computeRestarts <- base::computeRestarts
[17:29:23.957]                           grepl <- base::grepl
[17:29:23.957]                           restarts <- computeRestarts(cond)
[17:29:23.957]                           for (restart in restarts) {
[17:29:23.957]                             name <- restart$name
[17:29:23.957]                             if (is.null(name)) 
[17:29:23.957]                               next
[17:29:23.957]                             if (!grepl(pattern, name)) 
[17:29:23.957]                               next
[17:29:23.957]                             invokeRestart(restart)
[17:29:23.957]                             muffled <- TRUE
[17:29:23.957]                             break
[17:29:23.957]                           }
[17:29:23.957]                         }
[17:29:23.957]                       }
[17:29:23.957]                       invisible(muffled)
[17:29:23.957]                     }
[17:29:23.957]                     muffleCondition(cond, pattern = "^muffle")
[17:29:23.957]                   }
[17:29:23.957]                 }
[17:29:23.957]                 else {
[17:29:23.957]                   if (TRUE) {
[17:29:23.957]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:23.957]                     {
[17:29:23.957]                       inherits <- base::inherits
[17:29:23.957]                       invokeRestart <- base::invokeRestart
[17:29:23.957]                       is.null <- base::is.null
[17:29:23.957]                       muffled <- FALSE
[17:29:23.957]                       if (inherits(cond, "message")) {
[17:29:23.957]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:23.957]                         if (muffled) 
[17:29:23.957]                           invokeRestart("muffleMessage")
[17:29:23.957]                       }
[17:29:23.957]                       else if (inherits(cond, "warning")) {
[17:29:23.957]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:23.957]                         if (muffled) 
[17:29:23.957]                           invokeRestart("muffleWarning")
[17:29:23.957]                       }
[17:29:23.957]                       else if (inherits(cond, "condition")) {
[17:29:23.957]                         if (!is.null(pattern)) {
[17:29:23.957]                           computeRestarts <- base::computeRestarts
[17:29:23.957]                           grepl <- base::grepl
[17:29:23.957]                           restarts <- computeRestarts(cond)
[17:29:23.957]                           for (restart in restarts) {
[17:29:23.957]                             name <- restart$name
[17:29:23.957]                             if (is.null(name)) 
[17:29:23.957]                               next
[17:29:23.957]                             if (!grepl(pattern, name)) 
[17:29:23.957]                               next
[17:29:23.957]                             invokeRestart(restart)
[17:29:23.957]                             muffled <- TRUE
[17:29:23.957]                             break
[17:29:23.957]                           }
[17:29:23.957]                         }
[17:29:23.957]                       }
[17:29:23.957]                       invisible(muffled)
[17:29:23.957]                     }
[17:29:23.957]                     muffleCondition(cond, pattern = "^muffle")
[17:29:23.957]                   }
[17:29:23.957]                 }
[17:29:23.957]             }
[17:29:23.957]         }))
[17:29:23.957]     }, error = function(ex) {
[17:29:23.957]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:23.957]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:23.957]                 ...future.rng), started = ...future.startTime, 
[17:29:23.957]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:23.957]             version = "1.8"), class = "FutureResult")
[17:29:23.957]     }, finally = {
[17:29:23.957]         if (!identical(...future.workdir, getwd())) 
[17:29:23.957]             setwd(...future.workdir)
[17:29:23.957]         {
[17:29:23.957]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:23.957]                 ...future.oldOptions$nwarnings <- NULL
[17:29:23.957]             }
[17:29:23.957]             base::options(...future.oldOptions)
[17:29:23.957]             if (.Platform$OS.type == "windows") {
[17:29:23.957]                 old_names <- names(...future.oldEnvVars)
[17:29:23.957]                 envs <- base::Sys.getenv()
[17:29:23.957]                 names <- names(envs)
[17:29:23.957]                 common <- intersect(names, old_names)
[17:29:23.957]                 added <- setdiff(names, old_names)
[17:29:23.957]                 removed <- setdiff(old_names, names)
[17:29:23.957]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:23.957]                   envs[common]]
[17:29:23.957]                 NAMES <- toupper(changed)
[17:29:23.957]                 args <- list()
[17:29:23.957]                 for (kk in seq_along(NAMES)) {
[17:29:23.957]                   name <- changed[[kk]]
[17:29:23.957]                   NAME <- NAMES[[kk]]
[17:29:23.957]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:23.957]                     next
[17:29:23.957]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:23.957]                 }
[17:29:23.957]                 NAMES <- toupper(added)
[17:29:23.957]                 for (kk in seq_along(NAMES)) {
[17:29:23.957]                   name <- added[[kk]]
[17:29:23.957]                   NAME <- NAMES[[kk]]
[17:29:23.957]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:23.957]                     next
[17:29:23.957]                   args[[name]] <- ""
[17:29:23.957]                 }
[17:29:23.957]                 NAMES <- toupper(removed)
[17:29:23.957]                 for (kk in seq_along(NAMES)) {
[17:29:23.957]                   name <- removed[[kk]]
[17:29:23.957]                   NAME <- NAMES[[kk]]
[17:29:23.957]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:23.957]                     next
[17:29:23.957]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:23.957]                 }
[17:29:23.957]                 if (length(args) > 0) 
[17:29:23.957]                   base::do.call(base::Sys.setenv, args = args)
[17:29:23.957]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:23.957]             }
[17:29:23.957]             else {
[17:29:23.957]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:23.957]             }
[17:29:23.957]             {
[17:29:23.957]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:23.957]                   0L) {
[17:29:23.957]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:23.957]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:23.957]                   base::options(opts)
[17:29:23.957]                 }
[17:29:23.957]                 {
[17:29:23.957]                   {
[17:29:23.957]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:23.957]                     NULL
[17:29:23.957]                   }
[17:29:23.957]                   options(future.plan = NULL)
[17:29:23.957]                   if (is.na(NA_character_)) 
[17:29:23.957]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:23.957]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:23.957]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:23.957]                     .init = FALSE)
[17:29:23.957]                 }
[17:29:23.957]             }
[17:29:23.957]         }
[17:29:23.957]     })
[17:29:23.957]     if (TRUE) {
[17:29:23.957]         base::sink(type = "output", split = FALSE)
[17:29:23.957]         if (TRUE) {
[17:29:23.957]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:23.957]         }
[17:29:23.957]         else {
[17:29:23.957]             ...future.result["stdout"] <- base::list(NULL)
[17:29:23.957]         }
[17:29:23.957]         base::close(...future.stdout)
[17:29:23.957]         ...future.stdout <- NULL
[17:29:23.957]     }
[17:29:23.957]     ...future.result$conditions <- ...future.conditions
[17:29:23.957]     ...future.result$finished <- base::Sys.time()
[17:29:23.957]     ...future.result
[17:29:23.957] }
[17:29:23.967] MultisessionFuture started
[17:29:23.967] - Launch lazy future ... done
[17:29:23.968] run() for 'MultisessionFuture' ... done
[17:29:23.992] receiveMessageFromWorker() for ClusterFuture ...
[17:29:23.992] - Validating connection of MultisessionFuture
[17:29:23.993] - received message: FutureResult
[17:29:23.993] - Received FutureResult
[17:29:23.993] - Erased future from FutureRegistry
[17:29:23.993] result() for ClusterFuture ...
[17:29:23.994] - result already collected: FutureResult
[17:29:23.994] result() for ClusterFuture ... done
[17:29:23.994] signalConditions() ...
[17:29:23.994]  - include = 'immediateCondition'
[17:29:23.994]  - exclude = 
[17:29:23.994]  - resignal = FALSE
[17:29:23.995]  - Number of conditions: 1
[17:29:23.995] signalConditions() ... done
[17:29:23.995] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:23.995] A MultisessionFuture was resolved (and resolved itself)
- result = TRUE, recursive = Inf ... DONE
*** resolve() for Future objects ... DONE
*** resolve() for lists ...
[17:29:23.996] resolve() on list ...
[17:29:23.996]  recursive: 0
[17:29:23.996]  length: 2
[17:29:23.996]  elements: 'a', 'b'
[17:29:23.996]  length: 1 (resolved future 1)
[17:29:23.996]  length: 0 (resolved future 2)
[17:29:23.997] resolve() on list ... DONE
[17:29:23.997] getGlobalsAndPackages() ...
[17:29:23.997] Searching for globals...
[17:29:23.997] 
[17:29:23.998] Searching for globals ... DONE
[17:29:23.998] - globals: [0] <none>
[17:29:23.998] getGlobalsAndPackages() ... DONE
[17:29:23.998] run() for 'Future' ...
[17:29:23.998] - state: 'created'
[17:29:23.999] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:24.014] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:24.015] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:24.015]   - Field: 'node'
[17:29:24.015]   - Field: 'label'
[17:29:24.015]   - Field: 'local'
[17:29:24.015]   - Field: 'owner'
[17:29:24.016]   - Field: 'envir'
[17:29:24.016]   - Field: 'workers'
[17:29:24.016]   - Field: 'packages'
[17:29:24.016]   - Field: 'gc'
[17:29:24.016]   - Field: 'conditions'
[17:29:24.016]   - Field: 'persistent'
[17:29:24.017]   - Field: 'expr'
[17:29:24.017]   - Field: 'uuid'
[17:29:24.017]   - Field: 'seed'
[17:29:24.017]   - Field: 'version'
[17:29:24.017]   - Field: 'result'
[17:29:24.018]   - Field: 'asynchronous'
[17:29:24.018]   - Field: 'calls'
[17:29:24.018]   - Field: 'globals'
[17:29:24.018]   - Field: 'stdout'
[17:29:24.018]   - Field: 'earlySignal'
[17:29:24.018]   - Field: 'lazy'
[17:29:24.019]   - Field: 'state'
[17:29:24.019] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:24.019] - Launch lazy future ...
[17:29:24.019] Packages needed by the future expression (n = 0): <none>
[17:29:24.020] Packages needed by future strategies (n = 0): <none>
[17:29:24.020] {
[17:29:24.020]     {
[17:29:24.020]         {
[17:29:24.020]             ...future.startTime <- base::Sys.time()
[17:29:24.020]             {
[17:29:24.020]                 {
[17:29:24.020]                   {
[17:29:24.020]                     {
[17:29:24.020]                       base::local({
[17:29:24.020]                         has_future <- base::requireNamespace("future", 
[17:29:24.020]                           quietly = TRUE)
[17:29:24.020]                         if (has_future) {
[17:29:24.020]                           ns <- base::getNamespace("future")
[17:29:24.020]                           version <- ns[[".package"]][["version"]]
[17:29:24.020]                           if (is.null(version)) 
[17:29:24.020]                             version <- utils::packageVersion("future")
[17:29:24.020]                         }
[17:29:24.020]                         else {
[17:29:24.020]                           version <- NULL
[17:29:24.020]                         }
[17:29:24.020]                         if (!has_future || version < "1.8.0") {
[17:29:24.020]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:24.020]                             "", base::R.version$version.string), 
[17:29:24.020]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:24.020]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:24.020]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:24.020]                               "release", "version")], collapse = " "), 
[17:29:24.020]                             hostname = base::Sys.info()[["nodename"]])
[17:29:24.020]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:24.020]                             info)
[17:29:24.020]                           info <- base::paste(info, collapse = "; ")
[17:29:24.020]                           if (!has_future) {
[17:29:24.020]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:24.020]                               info)
[17:29:24.020]                           }
[17:29:24.020]                           else {
[17:29:24.020]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:24.020]                               info, version)
[17:29:24.020]                           }
[17:29:24.020]                           base::stop(msg)
[17:29:24.020]                         }
[17:29:24.020]                       })
[17:29:24.020]                     }
[17:29:24.020]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:24.020]                     base::options(mc.cores = 1L)
[17:29:24.020]                   }
[17:29:24.020]                   ...future.strategy.old <- future::plan("list")
[17:29:24.020]                   options(future.plan = NULL)
[17:29:24.020]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:24.020]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:24.020]                 }
[17:29:24.020]                 ...future.workdir <- getwd()
[17:29:24.020]             }
[17:29:24.020]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:24.020]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:24.020]         }
[17:29:24.020]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:24.020]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:24.020]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:24.020]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:24.020]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:24.020]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:24.020]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:24.020]             base::names(...future.oldOptions))
[17:29:24.020]     }
[17:29:24.020]     if (FALSE) {
[17:29:24.020]     }
[17:29:24.020]     else {
[17:29:24.020]         if (TRUE) {
[17:29:24.020]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:24.020]                 open = "w")
[17:29:24.020]         }
[17:29:24.020]         else {
[17:29:24.020]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:24.020]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:24.020]         }
[17:29:24.020]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:24.020]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:24.020]             base::sink(type = "output", split = FALSE)
[17:29:24.020]             base::close(...future.stdout)
[17:29:24.020]         }, add = TRUE)
[17:29:24.020]     }
[17:29:24.020]     ...future.frame <- base::sys.nframe()
[17:29:24.020]     ...future.conditions <- base::list()
[17:29:24.020]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:24.020]     if (FALSE) {
[17:29:24.020]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:24.020]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:24.020]     }
[17:29:24.020]     ...future.result <- base::tryCatch({
[17:29:24.020]         base::withCallingHandlers({
[17:29:24.020]             ...future.value <- base::withVisible(base::local({
[17:29:24.020]                 ...future.makeSendCondition <- base::local({
[17:29:24.020]                   sendCondition <- NULL
[17:29:24.020]                   function(frame = 1L) {
[17:29:24.020]                     if (is.function(sendCondition)) 
[17:29:24.020]                       return(sendCondition)
[17:29:24.020]                     ns <- getNamespace("parallel")
[17:29:24.020]                     if (exists("sendData", mode = "function", 
[17:29:24.020]                       envir = ns)) {
[17:29:24.020]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:24.020]                         envir = ns)
[17:29:24.020]                       envir <- sys.frame(frame)
[17:29:24.020]                       master <- NULL
[17:29:24.020]                       while (!identical(envir, .GlobalEnv) && 
[17:29:24.020]                         !identical(envir, emptyenv())) {
[17:29:24.020]                         if (exists("master", mode = "list", envir = envir, 
[17:29:24.020]                           inherits = FALSE)) {
[17:29:24.020]                           master <- get("master", mode = "list", 
[17:29:24.020]                             envir = envir, inherits = FALSE)
[17:29:24.020]                           if (inherits(master, c("SOCKnode", 
[17:29:24.020]                             "SOCK0node"))) {
[17:29:24.020]                             sendCondition <<- function(cond) {
[17:29:24.020]                               data <- list(type = "VALUE", value = cond, 
[17:29:24.020]                                 success = TRUE)
[17:29:24.020]                               parallel_sendData(master, data)
[17:29:24.020]                             }
[17:29:24.020]                             return(sendCondition)
[17:29:24.020]                           }
[17:29:24.020]                         }
[17:29:24.020]                         frame <- frame + 1L
[17:29:24.020]                         envir <- sys.frame(frame)
[17:29:24.020]                       }
[17:29:24.020]                     }
[17:29:24.020]                     sendCondition <<- function(cond) NULL
[17:29:24.020]                   }
[17:29:24.020]                 })
[17:29:24.020]                 withCallingHandlers({
[17:29:24.020]                   1
[17:29:24.020]                 }, immediateCondition = function(cond) {
[17:29:24.020]                   sendCondition <- ...future.makeSendCondition()
[17:29:24.020]                   sendCondition(cond)
[17:29:24.020]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:24.020]                   {
[17:29:24.020]                     inherits <- base::inherits
[17:29:24.020]                     invokeRestart <- base::invokeRestart
[17:29:24.020]                     is.null <- base::is.null
[17:29:24.020]                     muffled <- FALSE
[17:29:24.020]                     if (inherits(cond, "message")) {
[17:29:24.020]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:24.020]                       if (muffled) 
[17:29:24.020]                         invokeRestart("muffleMessage")
[17:29:24.020]                     }
[17:29:24.020]                     else if (inherits(cond, "warning")) {
[17:29:24.020]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:24.020]                       if (muffled) 
[17:29:24.020]                         invokeRestart("muffleWarning")
[17:29:24.020]                     }
[17:29:24.020]                     else if (inherits(cond, "condition")) {
[17:29:24.020]                       if (!is.null(pattern)) {
[17:29:24.020]                         computeRestarts <- base::computeRestarts
[17:29:24.020]                         grepl <- base::grepl
[17:29:24.020]                         restarts <- computeRestarts(cond)
[17:29:24.020]                         for (restart in restarts) {
[17:29:24.020]                           name <- restart$name
[17:29:24.020]                           if (is.null(name)) 
[17:29:24.020]                             next
[17:29:24.020]                           if (!grepl(pattern, name)) 
[17:29:24.020]                             next
[17:29:24.020]                           invokeRestart(restart)
[17:29:24.020]                           muffled <- TRUE
[17:29:24.020]                           break
[17:29:24.020]                         }
[17:29:24.020]                       }
[17:29:24.020]                     }
[17:29:24.020]                     invisible(muffled)
[17:29:24.020]                   }
[17:29:24.020]                   muffleCondition(cond)
[17:29:24.020]                 })
[17:29:24.020]             }))
[17:29:24.020]             future::FutureResult(value = ...future.value$value, 
[17:29:24.020]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:24.020]                   ...future.rng), globalenv = if (FALSE) 
[17:29:24.020]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:24.020]                     ...future.globalenv.names))
[17:29:24.020]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:24.020]         }, condition = base::local({
[17:29:24.020]             c <- base::c
[17:29:24.020]             inherits <- base::inherits
[17:29:24.020]             invokeRestart <- base::invokeRestart
[17:29:24.020]             length <- base::length
[17:29:24.020]             list <- base::list
[17:29:24.020]             seq.int <- base::seq.int
[17:29:24.020]             signalCondition <- base::signalCondition
[17:29:24.020]             sys.calls <- base::sys.calls
[17:29:24.020]             `[[` <- base::`[[`
[17:29:24.020]             `+` <- base::`+`
[17:29:24.020]             `<<-` <- base::`<<-`
[17:29:24.020]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:24.020]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:24.020]                   3L)]
[17:29:24.020]             }
[17:29:24.020]             function(cond) {
[17:29:24.020]                 is_error <- inherits(cond, "error")
[17:29:24.020]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:24.020]                   NULL)
[17:29:24.020]                 if (is_error) {
[17:29:24.020]                   sessionInformation <- function() {
[17:29:24.020]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:24.020]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:24.020]                       search = base::search(), system = base::Sys.info())
[17:29:24.020]                   }
[17:29:24.020]                   ...future.conditions[[length(...future.conditions) + 
[17:29:24.020]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:24.020]                     cond$call), session = sessionInformation(), 
[17:29:24.020]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:24.020]                   signalCondition(cond)
[17:29:24.020]                 }
[17:29:24.020]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:24.020]                 "immediateCondition"))) {
[17:29:24.020]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:24.020]                   ...future.conditions[[length(...future.conditions) + 
[17:29:24.020]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:24.020]                   if (TRUE && !signal) {
[17:29:24.020]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:24.020]                     {
[17:29:24.020]                       inherits <- base::inherits
[17:29:24.020]                       invokeRestart <- base::invokeRestart
[17:29:24.020]                       is.null <- base::is.null
[17:29:24.020]                       muffled <- FALSE
[17:29:24.020]                       if (inherits(cond, "message")) {
[17:29:24.020]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:24.020]                         if (muffled) 
[17:29:24.020]                           invokeRestart("muffleMessage")
[17:29:24.020]                       }
[17:29:24.020]                       else if (inherits(cond, "warning")) {
[17:29:24.020]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:24.020]                         if (muffled) 
[17:29:24.020]                           invokeRestart("muffleWarning")
[17:29:24.020]                       }
[17:29:24.020]                       else if (inherits(cond, "condition")) {
[17:29:24.020]                         if (!is.null(pattern)) {
[17:29:24.020]                           computeRestarts <- base::computeRestarts
[17:29:24.020]                           grepl <- base::grepl
[17:29:24.020]                           restarts <- computeRestarts(cond)
[17:29:24.020]                           for (restart in restarts) {
[17:29:24.020]                             name <- restart$name
[17:29:24.020]                             if (is.null(name)) 
[17:29:24.020]                               next
[17:29:24.020]                             if (!grepl(pattern, name)) 
[17:29:24.020]                               next
[17:29:24.020]                             invokeRestart(restart)
[17:29:24.020]                             muffled <- TRUE
[17:29:24.020]                             break
[17:29:24.020]                           }
[17:29:24.020]                         }
[17:29:24.020]                       }
[17:29:24.020]                       invisible(muffled)
[17:29:24.020]                     }
[17:29:24.020]                     muffleCondition(cond, pattern = "^muffle")
[17:29:24.020]                   }
[17:29:24.020]                 }
[17:29:24.020]                 else {
[17:29:24.020]                   if (TRUE) {
[17:29:24.020]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:24.020]                     {
[17:29:24.020]                       inherits <- base::inherits
[17:29:24.020]                       invokeRestart <- base::invokeRestart
[17:29:24.020]                       is.null <- base::is.null
[17:29:24.020]                       muffled <- FALSE
[17:29:24.020]                       if (inherits(cond, "message")) {
[17:29:24.020]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:24.020]                         if (muffled) 
[17:29:24.020]                           invokeRestart("muffleMessage")
[17:29:24.020]                       }
[17:29:24.020]                       else if (inherits(cond, "warning")) {
[17:29:24.020]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:24.020]                         if (muffled) 
[17:29:24.020]                           invokeRestart("muffleWarning")
[17:29:24.020]                       }
[17:29:24.020]                       else if (inherits(cond, "condition")) {
[17:29:24.020]                         if (!is.null(pattern)) {
[17:29:24.020]                           computeRestarts <- base::computeRestarts
[17:29:24.020]                           grepl <- base::grepl
[17:29:24.020]                           restarts <- computeRestarts(cond)
[17:29:24.020]                           for (restart in restarts) {
[17:29:24.020]                             name <- restart$name
[17:29:24.020]                             if (is.null(name)) 
[17:29:24.020]                               next
[17:29:24.020]                             if (!grepl(pattern, name)) 
[17:29:24.020]                               next
[17:29:24.020]                             invokeRestart(restart)
[17:29:24.020]                             muffled <- TRUE
[17:29:24.020]                             break
[17:29:24.020]                           }
[17:29:24.020]                         }
[17:29:24.020]                       }
[17:29:24.020]                       invisible(muffled)
[17:29:24.020]                     }
[17:29:24.020]                     muffleCondition(cond, pattern = "^muffle")
[17:29:24.020]                   }
[17:29:24.020]                 }
[17:29:24.020]             }
[17:29:24.020]         }))
[17:29:24.020]     }, error = function(ex) {
[17:29:24.020]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:24.020]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:24.020]                 ...future.rng), started = ...future.startTime, 
[17:29:24.020]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:24.020]             version = "1.8"), class = "FutureResult")
[17:29:24.020]     }, finally = {
[17:29:24.020]         if (!identical(...future.workdir, getwd())) 
[17:29:24.020]             setwd(...future.workdir)
[17:29:24.020]         {
[17:29:24.020]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:24.020]                 ...future.oldOptions$nwarnings <- NULL
[17:29:24.020]             }
[17:29:24.020]             base::options(...future.oldOptions)
[17:29:24.020]             if (.Platform$OS.type == "windows") {
[17:29:24.020]                 old_names <- names(...future.oldEnvVars)
[17:29:24.020]                 envs <- base::Sys.getenv()
[17:29:24.020]                 names <- names(envs)
[17:29:24.020]                 common <- intersect(names, old_names)
[17:29:24.020]                 added <- setdiff(names, old_names)
[17:29:24.020]                 removed <- setdiff(old_names, names)
[17:29:24.020]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:24.020]                   envs[common]]
[17:29:24.020]                 NAMES <- toupper(changed)
[17:29:24.020]                 args <- list()
[17:29:24.020]                 for (kk in seq_along(NAMES)) {
[17:29:24.020]                   name <- changed[[kk]]
[17:29:24.020]                   NAME <- NAMES[[kk]]
[17:29:24.020]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:24.020]                     next
[17:29:24.020]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:24.020]                 }
[17:29:24.020]                 NAMES <- toupper(added)
[17:29:24.020]                 for (kk in seq_along(NAMES)) {
[17:29:24.020]                   name <- added[[kk]]
[17:29:24.020]                   NAME <- NAMES[[kk]]
[17:29:24.020]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:24.020]                     next
[17:29:24.020]                   args[[name]] <- ""
[17:29:24.020]                 }
[17:29:24.020]                 NAMES <- toupper(removed)
[17:29:24.020]                 for (kk in seq_along(NAMES)) {
[17:29:24.020]                   name <- removed[[kk]]
[17:29:24.020]                   NAME <- NAMES[[kk]]
[17:29:24.020]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:24.020]                     next
[17:29:24.020]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:24.020]                 }
[17:29:24.020]                 if (length(args) > 0) 
[17:29:24.020]                   base::do.call(base::Sys.setenv, args = args)
[17:29:24.020]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:24.020]             }
[17:29:24.020]             else {
[17:29:24.020]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:24.020]             }
[17:29:24.020]             {
[17:29:24.020]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:24.020]                   0L) {
[17:29:24.020]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:24.020]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:24.020]                   base::options(opts)
[17:29:24.020]                 }
[17:29:24.020]                 {
[17:29:24.020]                   {
[17:29:24.020]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:24.020]                     NULL
[17:29:24.020]                   }
[17:29:24.020]                   options(future.plan = NULL)
[17:29:24.020]                   if (is.na(NA_character_)) 
[17:29:24.020]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:24.020]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:24.020]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:24.020]                     .init = FALSE)
[17:29:24.020]                 }
[17:29:24.020]             }
[17:29:24.020]         }
[17:29:24.020]     })
[17:29:24.020]     if (TRUE) {
[17:29:24.020]         base::sink(type = "output", split = FALSE)
[17:29:24.020]         if (TRUE) {
[17:29:24.020]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:24.020]         }
[17:29:24.020]         else {
[17:29:24.020]             ...future.result["stdout"] <- base::list(NULL)
[17:29:24.020]         }
[17:29:24.020]         base::close(...future.stdout)
[17:29:24.020]         ...future.stdout <- NULL
[17:29:24.020]     }
[17:29:24.020]     ...future.result$conditions <- ...future.conditions
[17:29:24.020]     ...future.result$finished <- base::Sys.time()
[17:29:24.020]     ...future.result
[17:29:24.020] }
[17:29:24.026] MultisessionFuture started
[17:29:24.027] - Launch lazy future ... done
[17:29:24.029] run() for 'MultisessionFuture' ... done
[17:29:24.030] getGlobalsAndPackages() ...
[17:29:24.030] Searching for globals...
[17:29:24.030] 
[17:29:24.031] Searching for globals ... DONE
[17:29:24.031] - globals: [0] <none>
[17:29:24.031] getGlobalsAndPackages() ... DONE
[17:29:24.031] run() for 'Future' ...
[17:29:24.031] - state: 'created'
[17:29:24.032] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:24.048] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:24.048] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:24.048]   - Field: 'node'
[17:29:24.048]   - Field: 'label'
[17:29:24.048]   - Field: 'local'
[17:29:24.049]   - Field: 'owner'
[17:29:24.049]   - Field: 'envir'
[17:29:24.049]   - Field: 'workers'
[17:29:24.049]   - Field: 'packages'
[17:29:24.049]   - Field: 'gc'
[17:29:24.049]   - Field: 'conditions'
[17:29:24.050]   - Field: 'persistent'
[17:29:24.050]   - Field: 'expr'
[17:29:24.050]   - Field: 'uuid'
[17:29:24.050]   - Field: 'seed'
[17:29:24.051]   - Field: 'version'
[17:29:24.051]   - Field: 'result'
[17:29:24.051]   - Field: 'asynchronous'
[17:29:24.052]   - Field: 'calls'
[17:29:24.052]   - Field: 'globals'
[17:29:24.052]   - Field: 'stdout'
[17:29:24.052]   - Field: 'earlySignal'
[17:29:24.053]   - Field: 'lazy'
[17:29:24.053]   - Field: 'state'
[17:29:24.053] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:24.054] - Launch lazy future ...
[17:29:24.054] Packages needed by the future expression (n = 0): <none>
[17:29:24.055] Packages needed by future strategies (n = 0): <none>
[17:29:24.056] {
[17:29:24.056]     {
[17:29:24.056]         {
[17:29:24.056]             ...future.startTime <- base::Sys.time()
[17:29:24.056]             {
[17:29:24.056]                 {
[17:29:24.056]                   {
[17:29:24.056]                     {
[17:29:24.056]                       base::local({
[17:29:24.056]                         has_future <- base::requireNamespace("future", 
[17:29:24.056]                           quietly = TRUE)
[17:29:24.056]                         if (has_future) {
[17:29:24.056]                           ns <- base::getNamespace("future")
[17:29:24.056]                           version <- ns[[".package"]][["version"]]
[17:29:24.056]                           if (is.null(version)) 
[17:29:24.056]                             version <- utils::packageVersion("future")
[17:29:24.056]                         }
[17:29:24.056]                         else {
[17:29:24.056]                           version <- NULL
[17:29:24.056]                         }
[17:29:24.056]                         if (!has_future || version < "1.8.0") {
[17:29:24.056]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:24.056]                             "", base::R.version$version.string), 
[17:29:24.056]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:24.056]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:24.056]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:24.056]                               "release", "version")], collapse = " "), 
[17:29:24.056]                             hostname = base::Sys.info()[["nodename"]])
[17:29:24.056]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:24.056]                             info)
[17:29:24.056]                           info <- base::paste(info, collapse = "; ")
[17:29:24.056]                           if (!has_future) {
[17:29:24.056]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:24.056]                               info)
[17:29:24.056]                           }
[17:29:24.056]                           else {
[17:29:24.056]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:24.056]                               info, version)
[17:29:24.056]                           }
[17:29:24.056]                           base::stop(msg)
[17:29:24.056]                         }
[17:29:24.056]                       })
[17:29:24.056]                     }
[17:29:24.056]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:24.056]                     base::options(mc.cores = 1L)
[17:29:24.056]                   }
[17:29:24.056]                   ...future.strategy.old <- future::plan("list")
[17:29:24.056]                   options(future.plan = NULL)
[17:29:24.056]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:24.056]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:24.056]                 }
[17:29:24.056]                 ...future.workdir <- getwd()
[17:29:24.056]             }
[17:29:24.056]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:24.056]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:24.056]         }
[17:29:24.056]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:24.056]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:24.056]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:24.056]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:24.056]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:24.056]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:24.056]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:24.056]             base::names(...future.oldOptions))
[17:29:24.056]     }
[17:29:24.056]     if (FALSE) {
[17:29:24.056]     }
[17:29:24.056]     else {
[17:29:24.056]         if (TRUE) {
[17:29:24.056]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:24.056]                 open = "w")
[17:29:24.056]         }
[17:29:24.056]         else {
[17:29:24.056]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:24.056]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:24.056]         }
[17:29:24.056]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:24.056]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:24.056]             base::sink(type = "output", split = FALSE)
[17:29:24.056]             base::close(...future.stdout)
[17:29:24.056]         }, add = TRUE)
[17:29:24.056]     }
[17:29:24.056]     ...future.frame <- base::sys.nframe()
[17:29:24.056]     ...future.conditions <- base::list()
[17:29:24.056]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:24.056]     if (FALSE) {
[17:29:24.056]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:24.056]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:24.056]     }
[17:29:24.056]     ...future.result <- base::tryCatch({
[17:29:24.056]         base::withCallingHandlers({
[17:29:24.056]             ...future.value <- base::withVisible(base::local({
[17:29:24.056]                 ...future.makeSendCondition <- base::local({
[17:29:24.056]                   sendCondition <- NULL
[17:29:24.056]                   function(frame = 1L) {
[17:29:24.056]                     if (is.function(sendCondition)) 
[17:29:24.056]                       return(sendCondition)
[17:29:24.056]                     ns <- getNamespace("parallel")
[17:29:24.056]                     if (exists("sendData", mode = "function", 
[17:29:24.056]                       envir = ns)) {
[17:29:24.056]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:24.056]                         envir = ns)
[17:29:24.056]                       envir <- sys.frame(frame)
[17:29:24.056]                       master <- NULL
[17:29:24.056]                       while (!identical(envir, .GlobalEnv) && 
[17:29:24.056]                         !identical(envir, emptyenv())) {
[17:29:24.056]                         if (exists("master", mode = "list", envir = envir, 
[17:29:24.056]                           inherits = FALSE)) {
[17:29:24.056]                           master <- get("master", mode = "list", 
[17:29:24.056]                             envir = envir, inherits = FALSE)
[17:29:24.056]                           if (inherits(master, c("SOCKnode", 
[17:29:24.056]                             "SOCK0node"))) {
[17:29:24.056]                             sendCondition <<- function(cond) {
[17:29:24.056]                               data <- list(type = "VALUE", value = cond, 
[17:29:24.056]                                 success = TRUE)
[17:29:24.056]                               parallel_sendData(master, data)
[17:29:24.056]                             }
[17:29:24.056]                             return(sendCondition)
[17:29:24.056]                           }
[17:29:24.056]                         }
[17:29:24.056]                         frame <- frame + 1L
[17:29:24.056]                         envir <- sys.frame(frame)
[17:29:24.056]                       }
[17:29:24.056]                     }
[17:29:24.056]                     sendCondition <<- function(cond) NULL
[17:29:24.056]                   }
[17:29:24.056]                 })
[17:29:24.056]                 withCallingHandlers({
[17:29:24.056]                   2
[17:29:24.056]                 }, immediateCondition = function(cond) {
[17:29:24.056]                   sendCondition <- ...future.makeSendCondition()
[17:29:24.056]                   sendCondition(cond)
[17:29:24.056]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:24.056]                   {
[17:29:24.056]                     inherits <- base::inherits
[17:29:24.056]                     invokeRestart <- base::invokeRestart
[17:29:24.056]                     is.null <- base::is.null
[17:29:24.056]                     muffled <- FALSE
[17:29:24.056]                     if (inherits(cond, "message")) {
[17:29:24.056]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:24.056]                       if (muffled) 
[17:29:24.056]                         invokeRestart("muffleMessage")
[17:29:24.056]                     }
[17:29:24.056]                     else if (inherits(cond, "warning")) {
[17:29:24.056]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:24.056]                       if (muffled) 
[17:29:24.056]                         invokeRestart("muffleWarning")
[17:29:24.056]                     }
[17:29:24.056]                     else if (inherits(cond, "condition")) {
[17:29:24.056]                       if (!is.null(pattern)) {
[17:29:24.056]                         computeRestarts <- base::computeRestarts
[17:29:24.056]                         grepl <- base::grepl
[17:29:24.056]                         restarts <- computeRestarts(cond)
[17:29:24.056]                         for (restart in restarts) {
[17:29:24.056]                           name <- restart$name
[17:29:24.056]                           if (is.null(name)) 
[17:29:24.056]                             next
[17:29:24.056]                           if (!grepl(pattern, name)) 
[17:29:24.056]                             next
[17:29:24.056]                           invokeRestart(restart)
[17:29:24.056]                           muffled <- TRUE
[17:29:24.056]                           break
[17:29:24.056]                         }
[17:29:24.056]                       }
[17:29:24.056]                     }
[17:29:24.056]                     invisible(muffled)
[17:29:24.056]                   }
[17:29:24.056]                   muffleCondition(cond)
[17:29:24.056]                 })
[17:29:24.056]             }))
[17:29:24.056]             future::FutureResult(value = ...future.value$value, 
[17:29:24.056]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:24.056]                   ...future.rng), globalenv = if (FALSE) 
[17:29:24.056]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:24.056]                     ...future.globalenv.names))
[17:29:24.056]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:24.056]         }, condition = base::local({
[17:29:24.056]             c <- base::c
[17:29:24.056]             inherits <- base::inherits
[17:29:24.056]             invokeRestart <- base::invokeRestart
[17:29:24.056]             length <- base::length
[17:29:24.056]             list <- base::list
[17:29:24.056]             seq.int <- base::seq.int
[17:29:24.056]             signalCondition <- base::signalCondition
[17:29:24.056]             sys.calls <- base::sys.calls
[17:29:24.056]             `[[` <- base::`[[`
[17:29:24.056]             `+` <- base::`+`
[17:29:24.056]             `<<-` <- base::`<<-`
[17:29:24.056]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:24.056]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:24.056]                   3L)]
[17:29:24.056]             }
[17:29:24.056]             function(cond) {
[17:29:24.056]                 is_error <- inherits(cond, "error")
[17:29:24.056]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:24.056]                   NULL)
[17:29:24.056]                 if (is_error) {
[17:29:24.056]                   sessionInformation <- function() {
[17:29:24.056]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:24.056]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:24.056]                       search = base::search(), system = base::Sys.info())
[17:29:24.056]                   }
[17:29:24.056]                   ...future.conditions[[length(...future.conditions) + 
[17:29:24.056]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:24.056]                     cond$call), session = sessionInformation(), 
[17:29:24.056]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:24.056]                   signalCondition(cond)
[17:29:24.056]                 }
[17:29:24.056]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:24.056]                 "immediateCondition"))) {
[17:29:24.056]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:24.056]                   ...future.conditions[[length(...future.conditions) + 
[17:29:24.056]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:24.056]                   if (TRUE && !signal) {
[17:29:24.056]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:24.056]                     {
[17:29:24.056]                       inherits <- base::inherits
[17:29:24.056]                       invokeRestart <- base::invokeRestart
[17:29:24.056]                       is.null <- base::is.null
[17:29:24.056]                       muffled <- FALSE
[17:29:24.056]                       if (inherits(cond, "message")) {
[17:29:24.056]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:24.056]                         if (muffled) 
[17:29:24.056]                           invokeRestart("muffleMessage")
[17:29:24.056]                       }
[17:29:24.056]                       else if (inherits(cond, "warning")) {
[17:29:24.056]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:24.056]                         if (muffled) 
[17:29:24.056]                           invokeRestart("muffleWarning")
[17:29:24.056]                       }
[17:29:24.056]                       else if (inherits(cond, "condition")) {
[17:29:24.056]                         if (!is.null(pattern)) {
[17:29:24.056]                           computeRestarts <- base::computeRestarts
[17:29:24.056]                           grepl <- base::grepl
[17:29:24.056]                           restarts <- computeRestarts(cond)
[17:29:24.056]                           for (restart in restarts) {
[17:29:24.056]                             name <- restart$name
[17:29:24.056]                             if (is.null(name)) 
[17:29:24.056]                               next
[17:29:24.056]                             if (!grepl(pattern, name)) 
[17:29:24.056]                               next
[17:29:24.056]                             invokeRestart(restart)
[17:29:24.056]                             muffled <- TRUE
[17:29:24.056]                             break
[17:29:24.056]                           }
[17:29:24.056]                         }
[17:29:24.056]                       }
[17:29:24.056]                       invisible(muffled)
[17:29:24.056]                     }
[17:29:24.056]                     muffleCondition(cond, pattern = "^muffle")
[17:29:24.056]                   }
[17:29:24.056]                 }
[17:29:24.056]                 else {
[17:29:24.056]                   if (TRUE) {
[17:29:24.056]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:24.056]                     {
[17:29:24.056]                       inherits <- base::inherits
[17:29:24.056]                       invokeRestart <- base::invokeRestart
[17:29:24.056]                       is.null <- base::is.null
[17:29:24.056]                       muffled <- FALSE
[17:29:24.056]                       if (inherits(cond, "message")) {
[17:29:24.056]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:24.056]                         if (muffled) 
[17:29:24.056]                           invokeRestart("muffleMessage")
[17:29:24.056]                       }
[17:29:24.056]                       else if (inherits(cond, "warning")) {
[17:29:24.056]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:24.056]                         if (muffled) 
[17:29:24.056]                           invokeRestart("muffleWarning")
[17:29:24.056]                       }
[17:29:24.056]                       else if (inherits(cond, "condition")) {
[17:29:24.056]                         if (!is.null(pattern)) {
[17:29:24.056]                           computeRestarts <- base::computeRestarts
[17:29:24.056]                           grepl <- base::grepl
[17:29:24.056]                           restarts <- computeRestarts(cond)
[17:29:24.056]                           for (restart in restarts) {
[17:29:24.056]                             name <- restart$name
[17:29:24.056]                             if (is.null(name)) 
[17:29:24.056]                               next
[17:29:24.056]                             if (!grepl(pattern, name)) 
[17:29:24.056]                               next
[17:29:24.056]                             invokeRestart(restart)
[17:29:24.056]                             muffled <- TRUE
[17:29:24.056]                             break
[17:29:24.056]                           }
[17:29:24.056]                         }
[17:29:24.056]                       }
[17:29:24.056]                       invisible(muffled)
[17:29:24.056]                     }
[17:29:24.056]                     muffleCondition(cond, pattern = "^muffle")
[17:29:24.056]                   }
[17:29:24.056]                 }
[17:29:24.056]             }
[17:29:24.056]         }))
[17:29:24.056]     }, error = function(ex) {
[17:29:24.056]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:24.056]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:24.056]                 ...future.rng), started = ...future.startTime, 
[17:29:24.056]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:24.056]             version = "1.8"), class = "FutureResult")
[17:29:24.056]     }, finally = {
[17:29:24.056]         if (!identical(...future.workdir, getwd())) 
[17:29:24.056]             setwd(...future.workdir)
[17:29:24.056]         {
[17:29:24.056]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:24.056]                 ...future.oldOptions$nwarnings <- NULL
[17:29:24.056]             }
[17:29:24.056]             base::options(...future.oldOptions)
[17:29:24.056]             if (.Platform$OS.type == "windows") {
[17:29:24.056]                 old_names <- names(...future.oldEnvVars)
[17:29:24.056]                 envs <- base::Sys.getenv()
[17:29:24.056]                 names <- names(envs)
[17:29:24.056]                 common <- intersect(names, old_names)
[17:29:24.056]                 added <- setdiff(names, old_names)
[17:29:24.056]                 removed <- setdiff(old_names, names)
[17:29:24.056]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:24.056]                   envs[common]]
[17:29:24.056]                 NAMES <- toupper(changed)
[17:29:24.056]                 args <- list()
[17:29:24.056]                 for (kk in seq_along(NAMES)) {
[17:29:24.056]                   name <- changed[[kk]]
[17:29:24.056]                   NAME <- NAMES[[kk]]
[17:29:24.056]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:24.056]                     next
[17:29:24.056]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:24.056]                 }
[17:29:24.056]                 NAMES <- toupper(added)
[17:29:24.056]                 for (kk in seq_along(NAMES)) {
[17:29:24.056]                   name <- added[[kk]]
[17:29:24.056]                   NAME <- NAMES[[kk]]
[17:29:24.056]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:24.056]                     next
[17:29:24.056]                   args[[name]] <- ""
[17:29:24.056]                 }
[17:29:24.056]                 NAMES <- toupper(removed)
[17:29:24.056]                 for (kk in seq_along(NAMES)) {
[17:29:24.056]                   name <- removed[[kk]]
[17:29:24.056]                   NAME <- NAMES[[kk]]
[17:29:24.056]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:24.056]                     next
[17:29:24.056]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:24.056]                 }
[17:29:24.056]                 if (length(args) > 0) 
[17:29:24.056]                   base::do.call(base::Sys.setenv, args = args)
[17:29:24.056]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:24.056]             }
[17:29:24.056]             else {
[17:29:24.056]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:24.056]             }
[17:29:24.056]             {
[17:29:24.056]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:24.056]                   0L) {
[17:29:24.056]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:24.056]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:24.056]                   base::options(opts)
[17:29:24.056]                 }
[17:29:24.056]                 {
[17:29:24.056]                   {
[17:29:24.056]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:24.056]                     NULL
[17:29:24.056]                   }
[17:29:24.056]                   options(future.plan = NULL)
[17:29:24.056]                   if (is.na(NA_character_)) 
[17:29:24.056]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:24.056]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:24.056]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:24.056]                     .init = FALSE)
[17:29:24.056]                 }
[17:29:24.056]             }
[17:29:24.056]         }
[17:29:24.056]     })
[17:29:24.056]     if (TRUE) {
[17:29:24.056]         base::sink(type = "output", split = FALSE)
[17:29:24.056]         if (TRUE) {
[17:29:24.056]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:24.056]         }
[17:29:24.056]         else {
[17:29:24.056]             ...future.result["stdout"] <- base::list(NULL)
[17:29:24.056]         }
[17:29:24.056]         base::close(...future.stdout)
[17:29:24.056]         ...future.stdout <- NULL
[17:29:24.056]     }
[17:29:24.056]     ...future.result$conditions <- ...future.conditions
[17:29:24.056]     ...future.result$finished <- base::Sys.time()
[17:29:24.056]     ...future.result
[17:29:24.056] }
[17:29:24.063] Poll #1 (0): usedNodes() = 2, workers = 2
[17:29:24.082] receiveMessageFromWorker() for ClusterFuture ...
[17:29:24.082] - Validating connection of MultisessionFuture
[17:29:24.082] - received message: FutureResult
[17:29:24.083] - Received FutureResult
[17:29:24.083] - Erased future from FutureRegistry
[17:29:24.083] result() for ClusterFuture ...
[17:29:24.084] - result already collected: FutureResult
[17:29:24.084] result() for ClusterFuture ... done
[17:29:24.084] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:24.084] result() for ClusterFuture ...
[17:29:24.085] - result already collected: FutureResult
[17:29:24.085] result() for ClusterFuture ... done
[17:29:24.085] result() for ClusterFuture ...
[17:29:24.086] - result already collected: FutureResult
[17:29:24.086] result() for ClusterFuture ... done
[17:29:24.088] MultisessionFuture started
[17:29:24.088] - Launch lazy future ... done
[17:29:24.088] run() for 'MultisessionFuture' ... done
[17:29:24.089] resolve() on list ...
[17:29:24.089]  recursive: 0
[17:29:24.089]  length: 3
[17:29:24.090]  elements: 'a', 'b', ''
[17:29:24.090] receiveMessageFromWorker() for ClusterFuture ...
[17:29:24.091] - Validating connection of MultisessionFuture
[17:29:24.091] - received message: FutureResult
[17:29:24.092] - Received FutureResult
[17:29:24.092] - Erased future from FutureRegistry
[17:29:24.092] result() for ClusterFuture ...
[17:29:24.092] - result already collected: FutureResult
[17:29:24.093] result() for ClusterFuture ... done
[17:29:24.093] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:24.093] Future #1
[17:29:24.093]  length: 2 (resolved future 1)
[17:29:24.139] receiveMessageFromWorker() for ClusterFuture ...
[17:29:24.139] - Validating connection of MultisessionFuture
[17:29:24.140] - received message: FutureResult
[17:29:24.140] - Received FutureResult
[17:29:24.140] - Erased future from FutureRegistry
[17:29:24.140] result() for ClusterFuture ...
[17:29:24.140] - result already collected: FutureResult
[17:29:24.141] result() for ClusterFuture ... done
[17:29:24.141] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:24.141] Future #2
[17:29:24.141]  length: 1 (resolved future 2)
[17:29:24.141]  length: 0 (resolved future 3)
[17:29:24.141] resolve() on list ... DONE
[17:29:24.142] getGlobalsAndPackages() ...
[17:29:24.142] Searching for globals...
[17:29:24.142] 
[17:29:24.142] Searching for globals ... DONE
[17:29:24.142] - globals: [0] <none>
[17:29:24.143] getGlobalsAndPackages() ... DONE
[17:29:24.143] getGlobalsAndPackages() ...
[17:29:24.143] Searching for globals...
[17:29:24.144] 
[17:29:24.144] Searching for globals ... DONE
[17:29:24.144] - globals: [0] <none>
[17:29:24.144] getGlobalsAndPackages() ... DONE
[17:29:24.145] run() for 'Future' ...
[17:29:24.145] - state: 'created'
[17:29:24.145] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:24.160] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:24.161] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:24.161]   - Field: 'node'
[17:29:24.161]   - Field: 'label'
[17:29:24.161]   - Field: 'local'
[17:29:24.161]   - Field: 'owner'
[17:29:24.162]   - Field: 'envir'
[17:29:24.162]   - Field: 'workers'
[17:29:24.162]   - Field: 'packages'
[17:29:24.162]   - Field: 'gc'
[17:29:24.162]   - Field: 'conditions'
[17:29:24.162]   - Field: 'persistent'
[17:29:24.162]   - Field: 'expr'
[17:29:24.163]   - Field: 'uuid'
[17:29:24.163]   - Field: 'seed'
[17:29:24.163]   - Field: 'version'
[17:29:24.163]   - Field: 'result'
[17:29:24.163]   - Field: 'asynchronous'
[17:29:24.163]   - Field: 'calls'
[17:29:24.164]   - Field: 'globals'
[17:29:24.164]   - Field: 'stdout'
[17:29:24.164]   - Field: 'earlySignal'
[17:29:24.164]   - Field: 'lazy'
[17:29:24.164]   - Field: 'state'
[17:29:24.164] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:24.165] - Launch lazy future ...
[17:29:24.165] Packages needed by the future expression (n = 0): <none>
[17:29:24.165] Packages needed by future strategies (n = 0): <none>
[17:29:24.166] {
[17:29:24.166]     {
[17:29:24.166]         {
[17:29:24.166]             ...future.startTime <- base::Sys.time()
[17:29:24.166]             {
[17:29:24.166]                 {
[17:29:24.166]                   {
[17:29:24.166]                     {
[17:29:24.166]                       base::local({
[17:29:24.166]                         has_future <- base::requireNamespace("future", 
[17:29:24.166]                           quietly = TRUE)
[17:29:24.166]                         if (has_future) {
[17:29:24.166]                           ns <- base::getNamespace("future")
[17:29:24.166]                           version <- ns[[".package"]][["version"]]
[17:29:24.166]                           if (is.null(version)) 
[17:29:24.166]                             version <- utils::packageVersion("future")
[17:29:24.166]                         }
[17:29:24.166]                         else {
[17:29:24.166]                           version <- NULL
[17:29:24.166]                         }
[17:29:24.166]                         if (!has_future || version < "1.8.0") {
[17:29:24.166]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:24.166]                             "", base::R.version$version.string), 
[17:29:24.166]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:24.166]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:24.166]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:24.166]                               "release", "version")], collapse = " "), 
[17:29:24.166]                             hostname = base::Sys.info()[["nodename"]])
[17:29:24.166]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:24.166]                             info)
[17:29:24.166]                           info <- base::paste(info, collapse = "; ")
[17:29:24.166]                           if (!has_future) {
[17:29:24.166]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:24.166]                               info)
[17:29:24.166]                           }
[17:29:24.166]                           else {
[17:29:24.166]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:24.166]                               info, version)
[17:29:24.166]                           }
[17:29:24.166]                           base::stop(msg)
[17:29:24.166]                         }
[17:29:24.166]                       })
[17:29:24.166]                     }
[17:29:24.166]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:24.166]                     base::options(mc.cores = 1L)
[17:29:24.166]                   }
[17:29:24.166]                   ...future.strategy.old <- future::plan("list")
[17:29:24.166]                   options(future.plan = NULL)
[17:29:24.166]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:24.166]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:24.166]                 }
[17:29:24.166]                 ...future.workdir <- getwd()
[17:29:24.166]             }
[17:29:24.166]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:24.166]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:24.166]         }
[17:29:24.166]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:24.166]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:24.166]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:24.166]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:24.166]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:24.166]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:24.166]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:24.166]             base::names(...future.oldOptions))
[17:29:24.166]     }
[17:29:24.166]     if (FALSE) {
[17:29:24.166]     }
[17:29:24.166]     else {
[17:29:24.166]         if (TRUE) {
[17:29:24.166]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:24.166]                 open = "w")
[17:29:24.166]         }
[17:29:24.166]         else {
[17:29:24.166]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:24.166]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:24.166]         }
[17:29:24.166]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:24.166]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:24.166]             base::sink(type = "output", split = FALSE)
[17:29:24.166]             base::close(...future.stdout)
[17:29:24.166]         }, add = TRUE)
[17:29:24.166]     }
[17:29:24.166]     ...future.frame <- base::sys.nframe()
[17:29:24.166]     ...future.conditions <- base::list()
[17:29:24.166]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:24.166]     if (FALSE) {
[17:29:24.166]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:24.166]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:24.166]     }
[17:29:24.166]     ...future.result <- base::tryCatch({
[17:29:24.166]         base::withCallingHandlers({
[17:29:24.166]             ...future.value <- base::withVisible(base::local({
[17:29:24.166]                 ...future.makeSendCondition <- base::local({
[17:29:24.166]                   sendCondition <- NULL
[17:29:24.166]                   function(frame = 1L) {
[17:29:24.166]                     if (is.function(sendCondition)) 
[17:29:24.166]                       return(sendCondition)
[17:29:24.166]                     ns <- getNamespace("parallel")
[17:29:24.166]                     if (exists("sendData", mode = "function", 
[17:29:24.166]                       envir = ns)) {
[17:29:24.166]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:24.166]                         envir = ns)
[17:29:24.166]                       envir <- sys.frame(frame)
[17:29:24.166]                       master <- NULL
[17:29:24.166]                       while (!identical(envir, .GlobalEnv) && 
[17:29:24.166]                         !identical(envir, emptyenv())) {
[17:29:24.166]                         if (exists("master", mode = "list", envir = envir, 
[17:29:24.166]                           inherits = FALSE)) {
[17:29:24.166]                           master <- get("master", mode = "list", 
[17:29:24.166]                             envir = envir, inherits = FALSE)
[17:29:24.166]                           if (inherits(master, c("SOCKnode", 
[17:29:24.166]                             "SOCK0node"))) {
[17:29:24.166]                             sendCondition <<- function(cond) {
[17:29:24.166]                               data <- list(type = "VALUE", value = cond, 
[17:29:24.166]                                 success = TRUE)
[17:29:24.166]                               parallel_sendData(master, data)
[17:29:24.166]                             }
[17:29:24.166]                             return(sendCondition)
[17:29:24.166]                           }
[17:29:24.166]                         }
[17:29:24.166]                         frame <- frame + 1L
[17:29:24.166]                         envir <- sys.frame(frame)
[17:29:24.166]                       }
[17:29:24.166]                     }
[17:29:24.166]                     sendCondition <<- function(cond) NULL
[17:29:24.166]                   }
[17:29:24.166]                 })
[17:29:24.166]                 withCallingHandlers({
[17:29:24.166]                   2
[17:29:24.166]                 }, immediateCondition = function(cond) {
[17:29:24.166]                   sendCondition <- ...future.makeSendCondition()
[17:29:24.166]                   sendCondition(cond)
[17:29:24.166]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:24.166]                   {
[17:29:24.166]                     inherits <- base::inherits
[17:29:24.166]                     invokeRestart <- base::invokeRestart
[17:29:24.166]                     is.null <- base::is.null
[17:29:24.166]                     muffled <- FALSE
[17:29:24.166]                     if (inherits(cond, "message")) {
[17:29:24.166]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:24.166]                       if (muffled) 
[17:29:24.166]                         invokeRestart("muffleMessage")
[17:29:24.166]                     }
[17:29:24.166]                     else if (inherits(cond, "warning")) {
[17:29:24.166]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:24.166]                       if (muffled) 
[17:29:24.166]                         invokeRestart("muffleWarning")
[17:29:24.166]                     }
[17:29:24.166]                     else if (inherits(cond, "condition")) {
[17:29:24.166]                       if (!is.null(pattern)) {
[17:29:24.166]                         computeRestarts <- base::computeRestarts
[17:29:24.166]                         grepl <- base::grepl
[17:29:24.166]                         restarts <- computeRestarts(cond)
[17:29:24.166]                         for (restart in restarts) {
[17:29:24.166]                           name <- restart$name
[17:29:24.166]                           if (is.null(name)) 
[17:29:24.166]                             next
[17:29:24.166]                           if (!grepl(pattern, name)) 
[17:29:24.166]                             next
[17:29:24.166]                           invokeRestart(restart)
[17:29:24.166]                           muffled <- TRUE
[17:29:24.166]                           break
[17:29:24.166]                         }
[17:29:24.166]                       }
[17:29:24.166]                     }
[17:29:24.166]                     invisible(muffled)
[17:29:24.166]                   }
[17:29:24.166]                   muffleCondition(cond)
[17:29:24.166]                 })
[17:29:24.166]             }))
[17:29:24.166]             future::FutureResult(value = ...future.value$value, 
[17:29:24.166]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:24.166]                   ...future.rng), globalenv = if (FALSE) 
[17:29:24.166]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:24.166]                     ...future.globalenv.names))
[17:29:24.166]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:24.166]         }, condition = base::local({
[17:29:24.166]             c <- base::c
[17:29:24.166]             inherits <- base::inherits
[17:29:24.166]             invokeRestart <- base::invokeRestart
[17:29:24.166]             length <- base::length
[17:29:24.166]             list <- base::list
[17:29:24.166]             seq.int <- base::seq.int
[17:29:24.166]             signalCondition <- base::signalCondition
[17:29:24.166]             sys.calls <- base::sys.calls
[17:29:24.166]             `[[` <- base::`[[`
[17:29:24.166]             `+` <- base::`+`
[17:29:24.166]             `<<-` <- base::`<<-`
[17:29:24.166]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:24.166]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:24.166]                   3L)]
[17:29:24.166]             }
[17:29:24.166]             function(cond) {
[17:29:24.166]                 is_error <- inherits(cond, "error")
[17:29:24.166]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:24.166]                   NULL)
[17:29:24.166]                 if (is_error) {
[17:29:24.166]                   sessionInformation <- function() {
[17:29:24.166]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:24.166]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:24.166]                       search = base::search(), system = base::Sys.info())
[17:29:24.166]                   }
[17:29:24.166]                   ...future.conditions[[length(...future.conditions) + 
[17:29:24.166]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:24.166]                     cond$call), session = sessionInformation(), 
[17:29:24.166]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:24.166]                   signalCondition(cond)
[17:29:24.166]                 }
[17:29:24.166]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:24.166]                 "immediateCondition"))) {
[17:29:24.166]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:24.166]                   ...future.conditions[[length(...future.conditions) + 
[17:29:24.166]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:24.166]                   if (TRUE && !signal) {
[17:29:24.166]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:24.166]                     {
[17:29:24.166]                       inherits <- base::inherits
[17:29:24.166]                       invokeRestart <- base::invokeRestart
[17:29:24.166]                       is.null <- base::is.null
[17:29:24.166]                       muffled <- FALSE
[17:29:24.166]                       if (inherits(cond, "message")) {
[17:29:24.166]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:24.166]                         if (muffled) 
[17:29:24.166]                           invokeRestart("muffleMessage")
[17:29:24.166]                       }
[17:29:24.166]                       else if (inherits(cond, "warning")) {
[17:29:24.166]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:24.166]                         if (muffled) 
[17:29:24.166]                           invokeRestart("muffleWarning")
[17:29:24.166]                       }
[17:29:24.166]                       else if (inherits(cond, "condition")) {
[17:29:24.166]                         if (!is.null(pattern)) {
[17:29:24.166]                           computeRestarts <- base::computeRestarts
[17:29:24.166]                           grepl <- base::grepl
[17:29:24.166]                           restarts <- computeRestarts(cond)
[17:29:24.166]                           for (restart in restarts) {
[17:29:24.166]                             name <- restart$name
[17:29:24.166]                             if (is.null(name)) 
[17:29:24.166]                               next
[17:29:24.166]                             if (!grepl(pattern, name)) 
[17:29:24.166]                               next
[17:29:24.166]                             invokeRestart(restart)
[17:29:24.166]                             muffled <- TRUE
[17:29:24.166]                             break
[17:29:24.166]                           }
[17:29:24.166]                         }
[17:29:24.166]                       }
[17:29:24.166]                       invisible(muffled)
[17:29:24.166]                     }
[17:29:24.166]                     muffleCondition(cond, pattern = "^muffle")
[17:29:24.166]                   }
[17:29:24.166]                 }
[17:29:24.166]                 else {
[17:29:24.166]                   if (TRUE) {
[17:29:24.166]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:24.166]                     {
[17:29:24.166]                       inherits <- base::inherits
[17:29:24.166]                       invokeRestart <- base::invokeRestart
[17:29:24.166]                       is.null <- base::is.null
[17:29:24.166]                       muffled <- FALSE
[17:29:24.166]                       if (inherits(cond, "message")) {
[17:29:24.166]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:24.166]                         if (muffled) 
[17:29:24.166]                           invokeRestart("muffleMessage")
[17:29:24.166]                       }
[17:29:24.166]                       else if (inherits(cond, "warning")) {
[17:29:24.166]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:24.166]                         if (muffled) 
[17:29:24.166]                           invokeRestart("muffleWarning")
[17:29:24.166]                       }
[17:29:24.166]                       else if (inherits(cond, "condition")) {
[17:29:24.166]                         if (!is.null(pattern)) {
[17:29:24.166]                           computeRestarts <- base::computeRestarts
[17:29:24.166]                           grepl <- base::grepl
[17:29:24.166]                           restarts <- computeRestarts(cond)
[17:29:24.166]                           for (restart in restarts) {
[17:29:24.166]                             name <- restart$name
[17:29:24.166]                             if (is.null(name)) 
[17:29:24.166]                               next
[17:29:24.166]                             if (!grepl(pattern, name)) 
[17:29:24.166]                               next
[17:29:24.166]                             invokeRestart(restart)
[17:29:24.166]                             muffled <- TRUE
[17:29:24.166]                             break
[17:29:24.166]                           }
[17:29:24.166]                         }
[17:29:24.166]                       }
[17:29:24.166]                       invisible(muffled)
[17:29:24.166]                     }
[17:29:24.166]                     muffleCondition(cond, pattern = "^muffle")
[17:29:24.166]                   }
[17:29:24.166]                 }
[17:29:24.166]             }
[17:29:24.166]         }))
[17:29:24.166]     }, error = function(ex) {
[17:29:24.166]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:24.166]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:24.166]                 ...future.rng), started = ...future.startTime, 
[17:29:24.166]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:24.166]             version = "1.8"), class = "FutureResult")
[17:29:24.166]     }, finally = {
[17:29:24.166]         if (!identical(...future.workdir, getwd())) 
[17:29:24.166]             setwd(...future.workdir)
[17:29:24.166]         {
[17:29:24.166]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:24.166]                 ...future.oldOptions$nwarnings <- NULL
[17:29:24.166]             }
[17:29:24.166]             base::options(...future.oldOptions)
[17:29:24.166]             if (.Platform$OS.type == "windows") {
[17:29:24.166]                 old_names <- names(...future.oldEnvVars)
[17:29:24.166]                 envs <- base::Sys.getenv()
[17:29:24.166]                 names <- names(envs)
[17:29:24.166]                 common <- intersect(names, old_names)
[17:29:24.166]                 added <- setdiff(names, old_names)
[17:29:24.166]                 removed <- setdiff(old_names, names)
[17:29:24.166]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:24.166]                   envs[common]]
[17:29:24.166]                 NAMES <- toupper(changed)
[17:29:24.166]                 args <- list()
[17:29:24.166]                 for (kk in seq_along(NAMES)) {
[17:29:24.166]                   name <- changed[[kk]]
[17:29:24.166]                   NAME <- NAMES[[kk]]
[17:29:24.166]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:24.166]                     next
[17:29:24.166]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:24.166]                 }
[17:29:24.166]                 NAMES <- toupper(added)
[17:29:24.166]                 for (kk in seq_along(NAMES)) {
[17:29:24.166]                   name <- added[[kk]]
[17:29:24.166]                   NAME <- NAMES[[kk]]
[17:29:24.166]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:24.166]                     next
[17:29:24.166]                   args[[name]] <- ""
[17:29:24.166]                 }
[17:29:24.166]                 NAMES <- toupper(removed)
[17:29:24.166]                 for (kk in seq_along(NAMES)) {
[17:29:24.166]                   name <- removed[[kk]]
[17:29:24.166]                   NAME <- NAMES[[kk]]
[17:29:24.166]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:24.166]                     next
[17:29:24.166]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:24.166]                 }
[17:29:24.166]                 if (length(args) > 0) 
[17:29:24.166]                   base::do.call(base::Sys.setenv, args = args)
[17:29:24.166]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:24.166]             }
[17:29:24.166]             else {
[17:29:24.166]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:24.166]             }
[17:29:24.166]             {
[17:29:24.166]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:24.166]                   0L) {
[17:29:24.166]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:24.166]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:24.166]                   base::options(opts)
[17:29:24.166]                 }
[17:29:24.166]                 {
[17:29:24.166]                   {
[17:29:24.166]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:24.166]                     NULL
[17:29:24.166]                   }
[17:29:24.166]                   options(future.plan = NULL)
[17:29:24.166]                   if (is.na(NA_character_)) 
[17:29:24.166]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:24.166]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:24.166]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:24.166]                     .init = FALSE)
[17:29:24.166]                 }
[17:29:24.166]             }
[17:29:24.166]         }
[17:29:24.166]     })
[17:29:24.166]     if (TRUE) {
[17:29:24.166]         base::sink(type = "output", split = FALSE)
[17:29:24.166]         if (TRUE) {
[17:29:24.166]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:24.166]         }
[17:29:24.166]         else {
[17:29:24.166]             ...future.result["stdout"] <- base::list(NULL)
[17:29:24.166]         }
[17:29:24.166]         base::close(...future.stdout)
[17:29:24.166]         ...future.stdout <- NULL
[17:29:24.166]     }
[17:29:24.166]     ...future.result$conditions <- ...future.conditions
[17:29:24.166]     ...future.result$finished <- base::Sys.time()
[17:29:24.166]     ...future.result
[17:29:24.166] }
[17:29:24.172] MultisessionFuture started
[17:29:24.172] - Launch lazy future ... done
[17:29:24.172] run() for 'MultisessionFuture' ... done
[17:29:24.172] resolve() on list ...
[17:29:24.172]  recursive: 0
[17:29:24.172]  length: 3
[17:29:24.173]  elements: 'a', 'b', ''
[17:29:24.173] run() for 'Future' ...
[17:29:24.173] - state: 'created'
[17:29:24.173] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:24.188] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:24.189] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:24.189]   - Field: 'node'
[17:29:24.189]   - Field: 'label'
[17:29:24.189]   - Field: 'local'
[17:29:24.189]   - Field: 'owner'
[17:29:24.190]   - Field: 'envir'
[17:29:24.190]   - Field: 'workers'
[17:29:24.190]   - Field: 'packages'
[17:29:24.190]   - Field: 'gc'
[17:29:24.190]   - Field: 'conditions'
[17:29:24.191]   - Field: 'persistent'
[17:29:24.191]   - Field: 'expr'
[17:29:24.191]   - Field: 'uuid'
[17:29:24.192]   - Field: 'seed'
[17:29:24.192]   - Field: 'version'
[17:29:24.192]   - Field: 'result'
[17:29:24.192]   - Field: 'asynchronous'
[17:29:24.192]   - Field: 'calls'
[17:29:24.192]   - Field: 'globals'
[17:29:24.193]   - Field: 'stdout'
[17:29:24.193]   - Field: 'earlySignal'
[17:29:24.193]   - Field: 'lazy'
[17:29:24.193]   - Field: 'state'
[17:29:24.193] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:24.193] - Launch lazy future ...
[17:29:24.194] Packages needed by the future expression (n = 0): <none>
[17:29:24.194] Packages needed by future strategies (n = 0): <none>
[17:29:24.195] {
[17:29:24.195]     {
[17:29:24.195]         {
[17:29:24.195]             ...future.startTime <- base::Sys.time()
[17:29:24.195]             {
[17:29:24.195]                 {
[17:29:24.195]                   {
[17:29:24.195]                     {
[17:29:24.195]                       base::local({
[17:29:24.195]                         has_future <- base::requireNamespace("future", 
[17:29:24.195]                           quietly = TRUE)
[17:29:24.195]                         if (has_future) {
[17:29:24.195]                           ns <- base::getNamespace("future")
[17:29:24.195]                           version <- ns[[".package"]][["version"]]
[17:29:24.195]                           if (is.null(version)) 
[17:29:24.195]                             version <- utils::packageVersion("future")
[17:29:24.195]                         }
[17:29:24.195]                         else {
[17:29:24.195]                           version <- NULL
[17:29:24.195]                         }
[17:29:24.195]                         if (!has_future || version < "1.8.0") {
[17:29:24.195]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:24.195]                             "", base::R.version$version.string), 
[17:29:24.195]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:24.195]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:24.195]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:24.195]                               "release", "version")], collapse = " "), 
[17:29:24.195]                             hostname = base::Sys.info()[["nodename"]])
[17:29:24.195]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:24.195]                             info)
[17:29:24.195]                           info <- base::paste(info, collapse = "; ")
[17:29:24.195]                           if (!has_future) {
[17:29:24.195]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:24.195]                               info)
[17:29:24.195]                           }
[17:29:24.195]                           else {
[17:29:24.195]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:24.195]                               info, version)
[17:29:24.195]                           }
[17:29:24.195]                           base::stop(msg)
[17:29:24.195]                         }
[17:29:24.195]                       })
[17:29:24.195]                     }
[17:29:24.195]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:24.195]                     base::options(mc.cores = 1L)
[17:29:24.195]                   }
[17:29:24.195]                   ...future.strategy.old <- future::plan("list")
[17:29:24.195]                   options(future.plan = NULL)
[17:29:24.195]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:24.195]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:24.195]                 }
[17:29:24.195]                 ...future.workdir <- getwd()
[17:29:24.195]             }
[17:29:24.195]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:24.195]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:24.195]         }
[17:29:24.195]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:24.195]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:24.195]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:24.195]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:24.195]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:24.195]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:24.195]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:24.195]             base::names(...future.oldOptions))
[17:29:24.195]     }
[17:29:24.195]     if (FALSE) {
[17:29:24.195]     }
[17:29:24.195]     else {
[17:29:24.195]         if (TRUE) {
[17:29:24.195]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:24.195]                 open = "w")
[17:29:24.195]         }
[17:29:24.195]         else {
[17:29:24.195]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:24.195]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:24.195]         }
[17:29:24.195]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:24.195]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:24.195]             base::sink(type = "output", split = FALSE)
[17:29:24.195]             base::close(...future.stdout)
[17:29:24.195]         }, add = TRUE)
[17:29:24.195]     }
[17:29:24.195]     ...future.frame <- base::sys.nframe()
[17:29:24.195]     ...future.conditions <- base::list()
[17:29:24.195]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:24.195]     if (FALSE) {
[17:29:24.195]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:24.195]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:24.195]     }
[17:29:24.195]     ...future.result <- base::tryCatch({
[17:29:24.195]         base::withCallingHandlers({
[17:29:24.195]             ...future.value <- base::withVisible(base::local({
[17:29:24.195]                 ...future.makeSendCondition <- base::local({
[17:29:24.195]                   sendCondition <- NULL
[17:29:24.195]                   function(frame = 1L) {
[17:29:24.195]                     if (is.function(sendCondition)) 
[17:29:24.195]                       return(sendCondition)
[17:29:24.195]                     ns <- getNamespace("parallel")
[17:29:24.195]                     if (exists("sendData", mode = "function", 
[17:29:24.195]                       envir = ns)) {
[17:29:24.195]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:24.195]                         envir = ns)
[17:29:24.195]                       envir <- sys.frame(frame)
[17:29:24.195]                       master <- NULL
[17:29:24.195]                       while (!identical(envir, .GlobalEnv) && 
[17:29:24.195]                         !identical(envir, emptyenv())) {
[17:29:24.195]                         if (exists("master", mode = "list", envir = envir, 
[17:29:24.195]                           inherits = FALSE)) {
[17:29:24.195]                           master <- get("master", mode = "list", 
[17:29:24.195]                             envir = envir, inherits = FALSE)
[17:29:24.195]                           if (inherits(master, c("SOCKnode", 
[17:29:24.195]                             "SOCK0node"))) {
[17:29:24.195]                             sendCondition <<- function(cond) {
[17:29:24.195]                               data <- list(type = "VALUE", value = cond, 
[17:29:24.195]                                 success = TRUE)
[17:29:24.195]                               parallel_sendData(master, data)
[17:29:24.195]                             }
[17:29:24.195]                             return(sendCondition)
[17:29:24.195]                           }
[17:29:24.195]                         }
[17:29:24.195]                         frame <- frame + 1L
[17:29:24.195]                         envir <- sys.frame(frame)
[17:29:24.195]                       }
[17:29:24.195]                     }
[17:29:24.195]                     sendCondition <<- function(cond) NULL
[17:29:24.195]                   }
[17:29:24.195]                 })
[17:29:24.195]                 withCallingHandlers({
[17:29:24.195]                   1
[17:29:24.195]                 }, immediateCondition = function(cond) {
[17:29:24.195]                   sendCondition <- ...future.makeSendCondition()
[17:29:24.195]                   sendCondition(cond)
[17:29:24.195]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:24.195]                   {
[17:29:24.195]                     inherits <- base::inherits
[17:29:24.195]                     invokeRestart <- base::invokeRestart
[17:29:24.195]                     is.null <- base::is.null
[17:29:24.195]                     muffled <- FALSE
[17:29:24.195]                     if (inherits(cond, "message")) {
[17:29:24.195]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:24.195]                       if (muffled) 
[17:29:24.195]                         invokeRestart("muffleMessage")
[17:29:24.195]                     }
[17:29:24.195]                     else if (inherits(cond, "warning")) {
[17:29:24.195]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:24.195]                       if (muffled) 
[17:29:24.195]                         invokeRestart("muffleWarning")
[17:29:24.195]                     }
[17:29:24.195]                     else if (inherits(cond, "condition")) {
[17:29:24.195]                       if (!is.null(pattern)) {
[17:29:24.195]                         computeRestarts <- base::computeRestarts
[17:29:24.195]                         grepl <- base::grepl
[17:29:24.195]                         restarts <- computeRestarts(cond)
[17:29:24.195]                         for (restart in restarts) {
[17:29:24.195]                           name <- restart$name
[17:29:24.195]                           if (is.null(name)) 
[17:29:24.195]                             next
[17:29:24.195]                           if (!grepl(pattern, name)) 
[17:29:24.195]                             next
[17:29:24.195]                           invokeRestart(restart)
[17:29:24.195]                           muffled <- TRUE
[17:29:24.195]                           break
[17:29:24.195]                         }
[17:29:24.195]                       }
[17:29:24.195]                     }
[17:29:24.195]                     invisible(muffled)
[17:29:24.195]                   }
[17:29:24.195]                   muffleCondition(cond)
[17:29:24.195]                 })
[17:29:24.195]             }))
[17:29:24.195]             future::FutureResult(value = ...future.value$value, 
[17:29:24.195]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:24.195]                   ...future.rng), globalenv = if (FALSE) 
[17:29:24.195]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:24.195]                     ...future.globalenv.names))
[17:29:24.195]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:24.195]         }, condition = base::local({
[17:29:24.195]             c <- base::c
[17:29:24.195]             inherits <- base::inherits
[17:29:24.195]             invokeRestart <- base::invokeRestart
[17:29:24.195]             length <- base::length
[17:29:24.195]             list <- base::list
[17:29:24.195]             seq.int <- base::seq.int
[17:29:24.195]             signalCondition <- base::signalCondition
[17:29:24.195]             sys.calls <- base::sys.calls
[17:29:24.195]             `[[` <- base::`[[`
[17:29:24.195]             `+` <- base::`+`
[17:29:24.195]             `<<-` <- base::`<<-`
[17:29:24.195]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:24.195]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:24.195]                   3L)]
[17:29:24.195]             }
[17:29:24.195]             function(cond) {
[17:29:24.195]                 is_error <- inherits(cond, "error")
[17:29:24.195]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:24.195]                   NULL)
[17:29:24.195]                 if (is_error) {
[17:29:24.195]                   sessionInformation <- function() {
[17:29:24.195]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:24.195]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:24.195]                       search = base::search(), system = base::Sys.info())
[17:29:24.195]                   }
[17:29:24.195]                   ...future.conditions[[length(...future.conditions) + 
[17:29:24.195]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:24.195]                     cond$call), session = sessionInformation(), 
[17:29:24.195]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:24.195]                   signalCondition(cond)
[17:29:24.195]                 }
[17:29:24.195]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:24.195]                 "immediateCondition"))) {
[17:29:24.195]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:24.195]                   ...future.conditions[[length(...future.conditions) + 
[17:29:24.195]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:24.195]                   if (TRUE && !signal) {
[17:29:24.195]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:24.195]                     {
[17:29:24.195]                       inherits <- base::inherits
[17:29:24.195]                       invokeRestart <- base::invokeRestart
[17:29:24.195]                       is.null <- base::is.null
[17:29:24.195]                       muffled <- FALSE
[17:29:24.195]                       if (inherits(cond, "message")) {
[17:29:24.195]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:24.195]                         if (muffled) 
[17:29:24.195]                           invokeRestart("muffleMessage")
[17:29:24.195]                       }
[17:29:24.195]                       else if (inherits(cond, "warning")) {
[17:29:24.195]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:24.195]                         if (muffled) 
[17:29:24.195]                           invokeRestart("muffleWarning")
[17:29:24.195]                       }
[17:29:24.195]                       else if (inherits(cond, "condition")) {
[17:29:24.195]                         if (!is.null(pattern)) {
[17:29:24.195]                           computeRestarts <- base::computeRestarts
[17:29:24.195]                           grepl <- base::grepl
[17:29:24.195]                           restarts <- computeRestarts(cond)
[17:29:24.195]                           for (restart in restarts) {
[17:29:24.195]                             name <- restart$name
[17:29:24.195]                             if (is.null(name)) 
[17:29:24.195]                               next
[17:29:24.195]                             if (!grepl(pattern, name)) 
[17:29:24.195]                               next
[17:29:24.195]                             invokeRestart(restart)
[17:29:24.195]                             muffled <- TRUE
[17:29:24.195]                             break
[17:29:24.195]                           }
[17:29:24.195]                         }
[17:29:24.195]                       }
[17:29:24.195]                       invisible(muffled)
[17:29:24.195]                     }
[17:29:24.195]                     muffleCondition(cond, pattern = "^muffle")
[17:29:24.195]                   }
[17:29:24.195]                 }
[17:29:24.195]                 else {
[17:29:24.195]                   if (TRUE) {
[17:29:24.195]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:24.195]                     {
[17:29:24.195]                       inherits <- base::inherits
[17:29:24.195]                       invokeRestart <- base::invokeRestart
[17:29:24.195]                       is.null <- base::is.null
[17:29:24.195]                       muffled <- FALSE
[17:29:24.195]                       if (inherits(cond, "message")) {
[17:29:24.195]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:24.195]                         if (muffled) 
[17:29:24.195]                           invokeRestart("muffleMessage")
[17:29:24.195]                       }
[17:29:24.195]                       else if (inherits(cond, "warning")) {
[17:29:24.195]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:24.195]                         if (muffled) 
[17:29:24.195]                           invokeRestart("muffleWarning")
[17:29:24.195]                       }
[17:29:24.195]                       else if (inherits(cond, "condition")) {
[17:29:24.195]                         if (!is.null(pattern)) {
[17:29:24.195]                           computeRestarts <- base::computeRestarts
[17:29:24.195]                           grepl <- base::grepl
[17:29:24.195]                           restarts <- computeRestarts(cond)
[17:29:24.195]                           for (restart in restarts) {
[17:29:24.195]                             name <- restart$name
[17:29:24.195]                             if (is.null(name)) 
[17:29:24.195]                               next
[17:29:24.195]                             if (!grepl(pattern, name)) 
[17:29:24.195]                               next
[17:29:24.195]                             invokeRestart(restart)
[17:29:24.195]                             muffled <- TRUE
[17:29:24.195]                             break
[17:29:24.195]                           }
[17:29:24.195]                         }
[17:29:24.195]                       }
[17:29:24.195]                       invisible(muffled)
[17:29:24.195]                     }
[17:29:24.195]                     muffleCondition(cond, pattern = "^muffle")
[17:29:24.195]                   }
[17:29:24.195]                 }
[17:29:24.195]             }
[17:29:24.195]         }))
[17:29:24.195]     }, error = function(ex) {
[17:29:24.195]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:24.195]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:24.195]                 ...future.rng), started = ...future.startTime, 
[17:29:24.195]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:24.195]             version = "1.8"), class = "FutureResult")
[17:29:24.195]     }, finally = {
[17:29:24.195]         if (!identical(...future.workdir, getwd())) 
[17:29:24.195]             setwd(...future.workdir)
[17:29:24.195]         {
[17:29:24.195]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:24.195]                 ...future.oldOptions$nwarnings <- NULL
[17:29:24.195]             }
[17:29:24.195]             base::options(...future.oldOptions)
[17:29:24.195]             if (.Platform$OS.type == "windows") {
[17:29:24.195]                 old_names <- names(...future.oldEnvVars)
[17:29:24.195]                 envs <- base::Sys.getenv()
[17:29:24.195]                 names <- names(envs)
[17:29:24.195]                 common <- intersect(names, old_names)
[17:29:24.195]                 added <- setdiff(names, old_names)
[17:29:24.195]                 removed <- setdiff(old_names, names)
[17:29:24.195]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:24.195]                   envs[common]]
[17:29:24.195]                 NAMES <- toupper(changed)
[17:29:24.195]                 args <- list()
[17:29:24.195]                 for (kk in seq_along(NAMES)) {
[17:29:24.195]                   name <- changed[[kk]]
[17:29:24.195]                   NAME <- NAMES[[kk]]
[17:29:24.195]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:24.195]                     next
[17:29:24.195]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:24.195]                 }
[17:29:24.195]                 NAMES <- toupper(added)
[17:29:24.195]                 for (kk in seq_along(NAMES)) {
[17:29:24.195]                   name <- added[[kk]]
[17:29:24.195]                   NAME <- NAMES[[kk]]
[17:29:24.195]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:24.195]                     next
[17:29:24.195]                   args[[name]] <- ""
[17:29:24.195]                 }
[17:29:24.195]                 NAMES <- toupper(removed)
[17:29:24.195]                 for (kk in seq_along(NAMES)) {
[17:29:24.195]                   name <- removed[[kk]]
[17:29:24.195]                   NAME <- NAMES[[kk]]
[17:29:24.195]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:24.195]                     next
[17:29:24.195]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:24.195]                 }
[17:29:24.195]                 if (length(args) > 0) 
[17:29:24.195]                   base::do.call(base::Sys.setenv, args = args)
[17:29:24.195]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:24.195]             }
[17:29:24.195]             else {
[17:29:24.195]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:24.195]             }
[17:29:24.195]             {
[17:29:24.195]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:24.195]                   0L) {
[17:29:24.195]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:24.195]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:24.195]                   base::options(opts)
[17:29:24.195]                 }
[17:29:24.195]                 {
[17:29:24.195]                   {
[17:29:24.195]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:24.195]                     NULL
[17:29:24.195]                   }
[17:29:24.195]                   options(future.plan = NULL)
[17:29:24.195]                   if (is.na(NA_character_)) 
[17:29:24.195]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:24.195]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:24.195]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:24.195]                     .init = FALSE)
[17:29:24.195]                 }
[17:29:24.195]             }
[17:29:24.195]         }
[17:29:24.195]     })
[17:29:24.195]     if (TRUE) {
[17:29:24.195]         base::sink(type = "output", split = FALSE)
[17:29:24.195]         if (TRUE) {
[17:29:24.195]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:24.195]         }
[17:29:24.195]         else {
[17:29:24.195]             ...future.result["stdout"] <- base::list(NULL)
[17:29:24.195]         }
[17:29:24.195]         base::close(...future.stdout)
[17:29:24.195]         ...future.stdout <- NULL
[17:29:24.195]     }
[17:29:24.195]     ...future.result$conditions <- ...future.conditions
[17:29:24.195]     ...future.result$finished <- base::Sys.time()
[17:29:24.195]     ...future.result
[17:29:24.195] }
[17:29:24.200] MultisessionFuture started
[17:29:24.200] - Launch lazy future ... done
[17:29:24.201] run() for 'MultisessionFuture' ... done
[17:29:24.217] receiveMessageFromWorker() for ClusterFuture ...
[17:29:24.217] - Validating connection of MultisessionFuture
[17:29:24.218] - received message: FutureResult
[17:29:24.218] - Received FutureResult
[17:29:24.218] - Erased future from FutureRegistry
[17:29:24.218] result() for ClusterFuture ...
[17:29:24.218] - result already collected: FutureResult
[17:29:24.219] result() for ClusterFuture ... done
[17:29:24.219] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:24.219] Future #1
[17:29:24.219]  length: 2 (resolved future 1)
[17:29:24.220] receiveMessageFromWorker() for ClusterFuture ...
[17:29:24.220] - Validating connection of MultisessionFuture
[17:29:24.220] - received message: FutureResult
[17:29:24.220] - Received FutureResult
[17:29:24.220] - Erased future from FutureRegistry
[17:29:24.221] result() for ClusterFuture ...
[17:29:24.221] - result already collected: FutureResult
[17:29:24.221] result() for ClusterFuture ... done
[17:29:24.221] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:24.221] Future #2
[17:29:24.221]  length: 1 (resolved future 2)
[17:29:24.222]  length: 0 (resolved future 3)
[17:29:24.222] resolve() on list ... DONE
[17:29:24.222] getGlobalsAndPackages() ...
[17:29:24.223] Searching for globals...
[17:29:24.224] 
[17:29:24.224] Searching for globals ... DONE
[17:29:24.224] - globals: [0] <none>
[17:29:24.224] getGlobalsAndPackages() ... DONE
[17:29:24.225] getGlobalsAndPackages() ...
[17:29:24.225] Searching for globals...
[17:29:24.226] 
[17:29:24.226] Searching for globals ... DONE
[17:29:24.226] - globals: [0] <none>
[17:29:24.226] getGlobalsAndPackages() ... DONE
[17:29:24.226] resolve() on list ...
[17:29:24.227]  recursive: 0
[17:29:24.227]  length: 3
[17:29:24.227]  elements: 'a', 'b', ''
[17:29:24.227] run() for 'Future' ...
[17:29:24.227] - state: 'created'
[17:29:24.227] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:24.245] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:24.246] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:24.246]   - Field: 'node'
[17:29:24.247]   - Field: 'label'
[17:29:24.247]   - Field: 'local'
[17:29:24.247]   - Field: 'owner'
[17:29:24.247]   - Field: 'envir'
[17:29:24.248]   - Field: 'workers'
[17:29:24.248]   - Field: 'packages'
[17:29:24.248]   - Field: 'gc'
[17:29:24.249]   - Field: 'conditions'
[17:29:24.249]   - Field: 'persistent'
[17:29:24.249]   - Field: 'expr'
[17:29:24.249]   - Field: 'uuid'
[17:29:24.250]   - Field: 'seed'
[17:29:24.250]   - Field: 'version'
[17:29:24.250]   - Field: 'result'
[17:29:24.251]   - Field: 'asynchronous'
[17:29:24.251]   - Field: 'calls'
[17:29:24.251]   - Field: 'globals'
[17:29:24.251]   - Field: 'stdout'
[17:29:24.252]   - Field: 'earlySignal'
[17:29:24.252]   - Field: 'lazy'
[17:29:24.252]   - Field: 'state'
[17:29:24.253] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:24.253] - Launch lazy future ...
[17:29:24.253] Packages needed by the future expression (n = 0): <none>
[17:29:24.254] Packages needed by future strategies (n = 0): <none>
[17:29:24.255] {
[17:29:24.255]     {
[17:29:24.255]         {
[17:29:24.255]             ...future.startTime <- base::Sys.time()
[17:29:24.255]             {
[17:29:24.255]                 {
[17:29:24.255]                   {
[17:29:24.255]                     {
[17:29:24.255]                       base::local({
[17:29:24.255]                         has_future <- base::requireNamespace("future", 
[17:29:24.255]                           quietly = TRUE)
[17:29:24.255]                         if (has_future) {
[17:29:24.255]                           ns <- base::getNamespace("future")
[17:29:24.255]                           version <- ns[[".package"]][["version"]]
[17:29:24.255]                           if (is.null(version)) 
[17:29:24.255]                             version <- utils::packageVersion("future")
[17:29:24.255]                         }
[17:29:24.255]                         else {
[17:29:24.255]                           version <- NULL
[17:29:24.255]                         }
[17:29:24.255]                         if (!has_future || version < "1.8.0") {
[17:29:24.255]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:24.255]                             "", base::R.version$version.string), 
[17:29:24.255]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:24.255]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:24.255]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:24.255]                               "release", "version")], collapse = " "), 
[17:29:24.255]                             hostname = base::Sys.info()[["nodename"]])
[17:29:24.255]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:24.255]                             info)
[17:29:24.255]                           info <- base::paste(info, collapse = "; ")
[17:29:24.255]                           if (!has_future) {
[17:29:24.255]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:24.255]                               info)
[17:29:24.255]                           }
[17:29:24.255]                           else {
[17:29:24.255]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:24.255]                               info, version)
[17:29:24.255]                           }
[17:29:24.255]                           base::stop(msg)
[17:29:24.255]                         }
[17:29:24.255]                       })
[17:29:24.255]                     }
[17:29:24.255]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:24.255]                     base::options(mc.cores = 1L)
[17:29:24.255]                   }
[17:29:24.255]                   ...future.strategy.old <- future::plan("list")
[17:29:24.255]                   options(future.plan = NULL)
[17:29:24.255]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:24.255]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:24.255]                 }
[17:29:24.255]                 ...future.workdir <- getwd()
[17:29:24.255]             }
[17:29:24.255]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:24.255]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:24.255]         }
[17:29:24.255]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:24.255]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:24.255]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:24.255]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:24.255]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:24.255]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:24.255]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:24.255]             base::names(...future.oldOptions))
[17:29:24.255]     }
[17:29:24.255]     if (FALSE) {
[17:29:24.255]     }
[17:29:24.255]     else {
[17:29:24.255]         if (TRUE) {
[17:29:24.255]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:24.255]                 open = "w")
[17:29:24.255]         }
[17:29:24.255]         else {
[17:29:24.255]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:24.255]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:24.255]         }
[17:29:24.255]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:24.255]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:24.255]             base::sink(type = "output", split = FALSE)
[17:29:24.255]             base::close(...future.stdout)
[17:29:24.255]         }, add = TRUE)
[17:29:24.255]     }
[17:29:24.255]     ...future.frame <- base::sys.nframe()
[17:29:24.255]     ...future.conditions <- base::list()
[17:29:24.255]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:24.255]     if (FALSE) {
[17:29:24.255]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:24.255]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:24.255]     }
[17:29:24.255]     ...future.result <- base::tryCatch({
[17:29:24.255]         base::withCallingHandlers({
[17:29:24.255]             ...future.value <- base::withVisible(base::local({
[17:29:24.255]                 ...future.makeSendCondition <- base::local({
[17:29:24.255]                   sendCondition <- NULL
[17:29:24.255]                   function(frame = 1L) {
[17:29:24.255]                     if (is.function(sendCondition)) 
[17:29:24.255]                       return(sendCondition)
[17:29:24.255]                     ns <- getNamespace("parallel")
[17:29:24.255]                     if (exists("sendData", mode = "function", 
[17:29:24.255]                       envir = ns)) {
[17:29:24.255]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:24.255]                         envir = ns)
[17:29:24.255]                       envir <- sys.frame(frame)
[17:29:24.255]                       master <- NULL
[17:29:24.255]                       while (!identical(envir, .GlobalEnv) && 
[17:29:24.255]                         !identical(envir, emptyenv())) {
[17:29:24.255]                         if (exists("master", mode = "list", envir = envir, 
[17:29:24.255]                           inherits = FALSE)) {
[17:29:24.255]                           master <- get("master", mode = "list", 
[17:29:24.255]                             envir = envir, inherits = FALSE)
[17:29:24.255]                           if (inherits(master, c("SOCKnode", 
[17:29:24.255]                             "SOCK0node"))) {
[17:29:24.255]                             sendCondition <<- function(cond) {
[17:29:24.255]                               data <- list(type = "VALUE", value = cond, 
[17:29:24.255]                                 success = TRUE)
[17:29:24.255]                               parallel_sendData(master, data)
[17:29:24.255]                             }
[17:29:24.255]                             return(sendCondition)
[17:29:24.255]                           }
[17:29:24.255]                         }
[17:29:24.255]                         frame <- frame + 1L
[17:29:24.255]                         envir <- sys.frame(frame)
[17:29:24.255]                       }
[17:29:24.255]                     }
[17:29:24.255]                     sendCondition <<- function(cond) NULL
[17:29:24.255]                   }
[17:29:24.255]                 })
[17:29:24.255]                 withCallingHandlers({
[17:29:24.255]                   1
[17:29:24.255]                 }, immediateCondition = function(cond) {
[17:29:24.255]                   sendCondition <- ...future.makeSendCondition()
[17:29:24.255]                   sendCondition(cond)
[17:29:24.255]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:24.255]                   {
[17:29:24.255]                     inherits <- base::inherits
[17:29:24.255]                     invokeRestart <- base::invokeRestart
[17:29:24.255]                     is.null <- base::is.null
[17:29:24.255]                     muffled <- FALSE
[17:29:24.255]                     if (inherits(cond, "message")) {
[17:29:24.255]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:24.255]                       if (muffled) 
[17:29:24.255]                         invokeRestart("muffleMessage")
[17:29:24.255]                     }
[17:29:24.255]                     else if (inherits(cond, "warning")) {
[17:29:24.255]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:24.255]                       if (muffled) 
[17:29:24.255]                         invokeRestart("muffleWarning")
[17:29:24.255]                     }
[17:29:24.255]                     else if (inherits(cond, "condition")) {
[17:29:24.255]                       if (!is.null(pattern)) {
[17:29:24.255]                         computeRestarts <- base::computeRestarts
[17:29:24.255]                         grepl <- base::grepl
[17:29:24.255]                         restarts <- computeRestarts(cond)
[17:29:24.255]                         for (restart in restarts) {
[17:29:24.255]                           name <- restart$name
[17:29:24.255]                           if (is.null(name)) 
[17:29:24.255]                             next
[17:29:24.255]                           if (!grepl(pattern, name)) 
[17:29:24.255]                             next
[17:29:24.255]                           invokeRestart(restart)
[17:29:24.255]                           muffled <- TRUE
[17:29:24.255]                           break
[17:29:24.255]                         }
[17:29:24.255]                       }
[17:29:24.255]                     }
[17:29:24.255]                     invisible(muffled)
[17:29:24.255]                   }
[17:29:24.255]                   muffleCondition(cond)
[17:29:24.255]                 })
[17:29:24.255]             }))
[17:29:24.255]             future::FutureResult(value = ...future.value$value, 
[17:29:24.255]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:24.255]                   ...future.rng), globalenv = if (FALSE) 
[17:29:24.255]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:24.255]                     ...future.globalenv.names))
[17:29:24.255]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:24.255]         }, condition = base::local({
[17:29:24.255]             c <- base::c
[17:29:24.255]             inherits <- base::inherits
[17:29:24.255]             invokeRestart <- base::invokeRestart
[17:29:24.255]             length <- base::length
[17:29:24.255]             list <- base::list
[17:29:24.255]             seq.int <- base::seq.int
[17:29:24.255]             signalCondition <- base::signalCondition
[17:29:24.255]             sys.calls <- base::sys.calls
[17:29:24.255]             `[[` <- base::`[[`
[17:29:24.255]             `+` <- base::`+`
[17:29:24.255]             `<<-` <- base::`<<-`
[17:29:24.255]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:24.255]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:24.255]                   3L)]
[17:29:24.255]             }
[17:29:24.255]             function(cond) {
[17:29:24.255]                 is_error <- inherits(cond, "error")
[17:29:24.255]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:24.255]                   NULL)
[17:29:24.255]                 if (is_error) {
[17:29:24.255]                   sessionInformation <- function() {
[17:29:24.255]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:24.255]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:24.255]                       search = base::search(), system = base::Sys.info())
[17:29:24.255]                   }
[17:29:24.255]                   ...future.conditions[[length(...future.conditions) + 
[17:29:24.255]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:24.255]                     cond$call), session = sessionInformation(), 
[17:29:24.255]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:24.255]                   signalCondition(cond)
[17:29:24.255]                 }
[17:29:24.255]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:24.255]                 "immediateCondition"))) {
[17:29:24.255]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:24.255]                   ...future.conditions[[length(...future.conditions) + 
[17:29:24.255]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:24.255]                   if (TRUE && !signal) {
[17:29:24.255]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:24.255]                     {
[17:29:24.255]                       inherits <- base::inherits
[17:29:24.255]                       invokeRestart <- base::invokeRestart
[17:29:24.255]                       is.null <- base::is.null
[17:29:24.255]                       muffled <- FALSE
[17:29:24.255]                       if (inherits(cond, "message")) {
[17:29:24.255]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:24.255]                         if (muffled) 
[17:29:24.255]                           invokeRestart("muffleMessage")
[17:29:24.255]                       }
[17:29:24.255]                       else if (inherits(cond, "warning")) {
[17:29:24.255]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:24.255]                         if (muffled) 
[17:29:24.255]                           invokeRestart("muffleWarning")
[17:29:24.255]                       }
[17:29:24.255]                       else if (inherits(cond, "condition")) {
[17:29:24.255]                         if (!is.null(pattern)) {
[17:29:24.255]                           computeRestarts <- base::computeRestarts
[17:29:24.255]                           grepl <- base::grepl
[17:29:24.255]                           restarts <- computeRestarts(cond)
[17:29:24.255]                           for (restart in restarts) {
[17:29:24.255]                             name <- restart$name
[17:29:24.255]                             if (is.null(name)) 
[17:29:24.255]                               next
[17:29:24.255]                             if (!grepl(pattern, name)) 
[17:29:24.255]                               next
[17:29:24.255]                             invokeRestart(restart)
[17:29:24.255]                             muffled <- TRUE
[17:29:24.255]                             break
[17:29:24.255]                           }
[17:29:24.255]                         }
[17:29:24.255]                       }
[17:29:24.255]                       invisible(muffled)
[17:29:24.255]                     }
[17:29:24.255]                     muffleCondition(cond, pattern = "^muffle")
[17:29:24.255]                   }
[17:29:24.255]                 }
[17:29:24.255]                 else {
[17:29:24.255]                   if (TRUE) {
[17:29:24.255]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:24.255]                     {
[17:29:24.255]                       inherits <- base::inherits
[17:29:24.255]                       invokeRestart <- base::invokeRestart
[17:29:24.255]                       is.null <- base::is.null
[17:29:24.255]                       muffled <- FALSE
[17:29:24.255]                       if (inherits(cond, "message")) {
[17:29:24.255]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:24.255]                         if (muffled) 
[17:29:24.255]                           invokeRestart("muffleMessage")
[17:29:24.255]                       }
[17:29:24.255]                       else if (inherits(cond, "warning")) {
[17:29:24.255]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:24.255]                         if (muffled) 
[17:29:24.255]                           invokeRestart("muffleWarning")
[17:29:24.255]                       }
[17:29:24.255]                       else if (inherits(cond, "condition")) {
[17:29:24.255]                         if (!is.null(pattern)) {
[17:29:24.255]                           computeRestarts <- base::computeRestarts
[17:29:24.255]                           grepl <- base::grepl
[17:29:24.255]                           restarts <- computeRestarts(cond)
[17:29:24.255]                           for (restart in restarts) {
[17:29:24.255]                             name <- restart$name
[17:29:24.255]                             if (is.null(name)) 
[17:29:24.255]                               next
[17:29:24.255]                             if (!grepl(pattern, name)) 
[17:29:24.255]                               next
[17:29:24.255]                             invokeRestart(restart)
[17:29:24.255]                             muffled <- TRUE
[17:29:24.255]                             break
[17:29:24.255]                           }
[17:29:24.255]                         }
[17:29:24.255]                       }
[17:29:24.255]                       invisible(muffled)
[17:29:24.255]                     }
[17:29:24.255]                     muffleCondition(cond, pattern = "^muffle")
[17:29:24.255]                   }
[17:29:24.255]                 }
[17:29:24.255]             }
[17:29:24.255]         }))
[17:29:24.255]     }, error = function(ex) {
[17:29:24.255]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:24.255]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:24.255]                 ...future.rng), started = ...future.startTime, 
[17:29:24.255]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:24.255]             version = "1.8"), class = "FutureResult")
[17:29:24.255]     }, finally = {
[17:29:24.255]         if (!identical(...future.workdir, getwd())) 
[17:29:24.255]             setwd(...future.workdir)
[17:29:24.255]         {
[17:29:24.255]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:24.255]                 ...future.oldOptions$nwarnings <- NULL
[17:29:24.255]             }
[17:29:24.255]             base::options(...future.oldOptions)
[17:29:24.255]             if (.Platform$OS.type == "windows") {
[17:29:24.255]                 old_names <- names(...future.oldEnvVars)
[17:29:24.255]                 envs <- base::Sys.getenv()
[17:29:24.255]                 names <- names(envs)
[17:29:24.255]                 common <- intersect(names, old_names)
[17:29:24.255]                 added <- setdiff(names, old_names)
[17:29:24.255]                 removed <- setdiff(old_names, names)
[17:29:24.255]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:24.255]                   envs[common]]
[17:29:24.255]                 NAMES <- toupper(changed)
[17:29:24.255]                 args <- list()
[17:29:24.255]                 for (kk in seq_along(NAMES)) {
[17:29:24.255]                   name <- changed[[kk]]
[17:29:24.255]                   NAME <- NAMES[[kk]]
[17:29:24.255]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:24.255]                     next
[17:29:24.255]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:24.255]                 }
[17:29:24.255]                 NAMES <- toupper(added)
[17:29:24.255]                 for (kk in seq_along(NAMES)) {
[17:29:24.255]                   name <- added[[kk]]
[17:29:24.255]                   NAME <- NAMES[[kk]]
[17:29:24.255]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:24.255]                     next
[17:29:24.255]                   args[[name]] <- ""
[17:29:24.255]                 }
[17:29:24.255]                 NAMES <- toupper(removed)
[17:29:24.255]                 for (kk in seq_along(NAMES)) {
[17:29:24.255]                   name <- removed[[kk]]
[17:29:24.255]                   NAME <- NAMES[[kk]]
[17:29:24.255]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:24.255]                     next
[17:29:24.255]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:24.255]                 }
[17:29:24.255]                 if (length(args) > 0) 
[17:29:24.255]                   base::do.call(base::Sys.setenv, args = args)
[17:29:24.255]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:24.255]             }
[17:29:24.255]             else {
[17:29:24.255]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:24.255]             }
[17:29:24.255]             {
[17:29:24.255]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:24.255]                   0L) {
[17:29:24.255]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:24.255]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:24.255]                   base::options(opts)
[17:29:24.255]                 }
[17:29:24.255]                 {
[17:29:24.255]                   {
[17:29:24.255]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:24.255]                     NULL
[17:29:24.255]                   }
[17:29:24.255]                   options(future.plan = NULL)
[17:29:24.255]                   if (is.na(NA_character_)) 
[17:29:24.255]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:24.255]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:24.255]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:24.255]                     .init = FALSE)
[17:29:24.255]                 }
[17:29:24.255]             }
[17:29:24.255]         }
[17:29:24.255]     })
[17:29:24.255]     if (TRUE) {
[17:29:24.255]         base::sink(type = "output", split = FALSE)
[17:29:24.255]         if (TRUE) {
[17:29:24.255]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:24.255]         }
[17:29:24.255]         else {
[17:29:24.255]             ...future.result["stdout"] <- base::list(NULL)
[17:29:24.255]         }
[17:29:24.255]         base::close(...future.stdout)
[17:29:24.255]         ...future.stdout <- NULL
[17:29:24.255]     }
[17:29:24.255]     ...future.result$conditions <- ...future.conditions
[17:29:24.255]     ...future.result$finished <- base::Sys.time()
[17:29:24.255]     ...future.result
[17:29:24.255] }
[17:29:24.263] MultisessionFuture started
[17:29:24.263] - Launch lazy future ... done
[17:29:24.263] run() for 'MultisessionFuture' ... done
[17:29:24.290] receiveMessageFromWorker() for ClusterFuture ...
[17:29:24.291] - Validating connection of MultisessionFuture
[17:29:24.291] - received message: FutureResult
[17:29:24.291] - Received FutureResult
[17:29:24.292] - Erased future from FutureRegistry
[17:29:24.292] result() for ClusterFuture ...
[17:29:24.292] - result already collected: FutureResult
[17:29:24.293] result() for ClusterFuture ... done
[17:29:24.293] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:24.293] Future #1
[17:29:24.294]  length: 2 (resolved future 1)
[17:29:24.294] run() for 'Future' ...
[17:29:24.294] - state: 'created'
[17:29:24.295] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:24.314] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:24.314] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:24.315]   - Field: 'node'
[17:29:24.315]   - Field: 'label'
[17:29:24.316]   - Field: 'local'
[17:29:24.316]   - Field: 'owner'
[17:29:24.316]   - Field: 'envir'
[17:29:24.317]   - Field: 'workers'
[17:29:24.317]   - Field: 'packages'
[17:29:24.317]   - Field: 'gc'
[17:29:24.318]   - Field: 'conditions'
[17:29:24.318]   - Field: 'persistent'
[17:29:24.318]   - Field: 'expr'
[17:29:24.318]   - Field: 'uuid'
[17:29:24.319]   - Field: 'seed'
[17:29:24.319]   - Field: 'version'
[17:29:24.319]   - Field: 'result'
[17:29:24.320]   - Field: 'asynchronous'
[17:29:24.320]   - Field: 'calls'
[17:29:24.320]   - Field: 'globals'
[17:29:24.321]   - Field: 'stdout'
[17:29:24.321]   - Field: 'earlySignal'
[17:29:24.321]   - Field: 'lazy'
[17:29:24.322]   - Field: 'state'
[17:29:24.322] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:24.322] - Launch lazy future ...
[17:29:24.323] Packages needed by the future expression (n = 0): <none>
[17:29:24.323] Packages needed by future strategies (n = 0): <none>
[17:29:24.324] {
[17:29:24.324]     {
[17:29:24.324]         {
[17:29:24.324]             ...future.startTime <- base::Sys.time()
[17:29:24.324]             {
[17:29:24.324]                 {
[17:29:24.324]                   {
[17:29:24.324]                     {
[17:29:24.324]                       base::local({
[17:29:24.324]                         has_future <- base::requireNamespace("future", 
[17:29:24.324]                           quietly = TRUE)
[17:29:24.324]                         if (has_future) {
[17:29:24.324]                           ns <- base::getNamespace("future")
[17:29:24.324]                           version <- ns[[".package"]][["version"]]
[17:29:24.324]                           if (is.null(version)) 
[17:29:24.324]                             version <- utils::packageVersion("future")
[17:29:24.324]                         }
[17:29:24.324]                         else {
[17:29:24.324]                           version <- NULL
[17:29:24.324]                         }
[17:29:24.324]                         if (!has_future || version < "1.8.0") {
[17:29:24.324]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:24.324]                             "", base::R.version$version.string), 
[17:29:24.324]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:24.324]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:24.324]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:24.324]                               "release", "version")], collapse = " "), 
[17:29:24.324]                             hostname = base::Sys.info()[["nodename"]])
[17:29:24.324]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:24.324]                             info)
[17:29:24.324]                           info <- base::paste(info, collapse = "; ")
[17:29:24.324]                           if (!has_future) {
[17:29:24.324]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:24.324]                               info)
[17:29:24.324]                           }
[17:29:24.324]                           else {
[17:29:24.324]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:24.324]                               info, version)
[17:29:24.324]                           }
[17:29:24.324]                           base::stop(msg)
[17:29:24.324]                         }
[17:29:24.324]                       })
[17:29:24.324]                     }
[17:29:24.324]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:24.324]                     base::options(mc.cores = 1L)
[17:29:24.324]                   }
[17:29:24.324]                   ...future.strategy.old <- future::plan("list")
[17:29:24.324]                   options(future.plan = NULL)
[17:29:24.324]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:24.324]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:24.324]                 }
[17:29:24.324]                 ...future.workdir <- getwd()
[17:29:24.324]             }
[17:29:24.324]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:24.324]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:24.324]         }
[17:29:24.324]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:24.324]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:24.324]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:24.324]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:24.324]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:24.324]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:24.324]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:24.324]             base::names(...future.oldOptions))
[17:29:24.324]     }
[17:29:24.324]     if (FALSE) {
[17:29:24.324]     }
[17:29:24.324]     else {
[17:29:24.324]         if (TRUE) {
[17:29:24.324]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:24.324]                 open = "w")
[17:29:24.324]         }
[17:29:24.324]         else {
[17:29:24.324]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:24.324]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:24.324]         }
[17:29:24.324]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:24.324]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:24.324]             base::sink(type = "output", split = FALSE)
[17:29:24.324]             base::close(...future.stdout)
[17:29:24.324]         }, add = TRUE)
[17:29:24.324]     }
[17:29:24.324]     ...future.frame <- base::sys.nframe()
[17:29:24.324]     ...future.conditions <- base::list()
[17:29:24.324]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:24.324]     if (FALSE) {
[17:29:24.324]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:24.324]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:24.324]     }
[17:29:24.324]     ...future.result <- base::tryCatch({
[17:29:24.324]         base::withCallingHandlers({
[17:29:24.324]             ...future.value <- base::withVisible(base::local({
[17:29:24.324]                 ...future.makeSendCondition <- base::local({
[17:29:24.324]                   sendCondition <- NULL
[17:29:24.324]                   function(frame = 1L) {
[17:29:24.324]                     if (is.function(sendCondition)) 
[17:29:24.324]                       return(sendCondition)
[17:29:24.324]                     ns <- getNamespace("parallel")
[17:29:24.324]                     if (exists("sendData", mode = "function", 
[17:29:24.324]                       envir = ns)) {
[17:29:24.324]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:24.324]                         envir = ns)
[17:29:24.324]                       envir <- sys.frame(frame)
[17:29:24.324]                       master <- NULL
[17:29:24.324]                       while (!identical(envir, .GlobalEnv) && 
[17:29:24.324]                         !identical(envir, emptyenv())) {
[17:29:24.324]                         if (exists("master", mode = "list", envir = envir, 
[17:29:24.324]                           inherits = FALSE)) {
[17:29:24.324]                           master <- get("master", mode = "list", 
[17:29:24.324]                             envir = envir, inherits = FALSE)
[17:29:24.324]                           if (inherits(master, c("SOCKnode", 
[17:29:24.324]                             "SOCK0node"))) {
[17:29:24.324]                             sendCondition <<- function(cond) {
[17:29:24.324]                               data <- list(type = "VALUE", value = cond, 
[17:29:24.324]                                 success = TRUE)
[17:29:24.324]                               parallel_sendData(master, data)
[17:29:24.324]                             }
[17:29:24.324]                             return(sendCondition)
[17:29:24.324]                           }
[17:29:24.324]                         }
[17:29:24.324]                         frame <- frame + 1L
[17:29:24.324]                         envir <- sys.frame(frame)
[17:29:24.324]                       }
[17:29:24.324]                     }
[17:29:24.324]                     sendCondition <<- function(cond) NULL
[17:29:24.324]                   }
[17:29:24.324]                 })
[17:29:24.324]                 withCallingHandlers({
[17:29:24.324]                   2
[17:29:24.324]                 }, immediateCondition = function(cond) {
[17:29:24.324]                   sendCondition <- ...future.makeSendCondition()
[17:29:24.324]                   sendCondition(cond)
[17:29:24.324]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:24.324]                   {
[17:29:24.324]                     inherits <- base::inherits
[17:29:24.324]                     invokeRestart <- base::invokeRestart
[17:29:24.324]                     is.null <- base::is.null
[17:29:24.324]                     muffled <- FALSE
[17:29:24.324]                     if (inherits(cond, "message")) {
[17:29:24.324]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:24.324]                       if (muffled) 
[17:29:24.324]                         invokeRestart("muffleMessage")
[17:29:24.324]                     }
[17:29:24.324]                     else if (inherits(cond, "warning")) {
[17:29:24.324]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:24.324]                       if (muffled) 
[17:29:24.324]                         invokeRestart("muffleWarning")
[17:29:24.324]                     }
[17:29:24.324]                     else if (inherits(cond, "condition")) {
[17:29:24.324]                       if (!is.null(pattern)) {
[17:29:24.324]                         computeRestarts <- base::computeRestarts
[17:29:24.324]                         grepl <- base::grepl
[17:29:24.324]                         restarts <- computeRestarts(cond)
[17:29:24.324]                         for (restart in restarts) {
[17:29:24.324]                           name <- restart$name
[17:29:24.324]                           if (is.null(name)) 
[17:29:24.324]                             next
[17:29:24.324]                           if (!grepl(pattern, name)) 
[17:29:24.324]                             next
[17:29:24.324]                           invokeRestart(restart)
[17:29:24.324]                           muffled <- TRUE
[17:29:24.324]                           break
[17:29:24.324]                         }
[17:29:24.324]                       }
[17:29:24.324]                     }
[17:29:24.324]                     invisible(muffled)
[17:29:24.324]                   }
[17:29:24.324]                   muffleCondition(cond)
[17:29:24.324]                 })
[17:29:24.324]             }))
[17:29:24.324]             future::FutureResult(value = ...future.value$value, 
[17:29:24.324]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:24.324]                   ...future.rng), globalenv = if (FALSE) 
[17:29:24.324]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:24.324]                     ...future.globalenv.names))
[17:29:24.324]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:24.324]         }, condition = base::local({
[17:29:24.324]             c <- base::c
[17:29:24.324]             inherits <- base::inherits
[17:29:24.324]             invokeRestart <- base::invokeRestart
[17:29:24.324]             length <- base::length
[17:29:24.324]             list <- base::list
[17:29:24.324]             seq.int <- base::seq.int
[17:29:24.324]             signalCondition <- base::signalCondition
[17:29:24.324]             sys.calls <- base::sys.calls
[17:29:24.324]             `[[` <- base::`[[`
[17:29:24.324]             `+` <- base::`+`
[17:29:24.324]             `<<-` <- base::`<<-`
[17:29:24.324]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:24.324]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:24.324]                   3L)]
[17:29:24.324]             }
[17:29:24.324]             function(cond) {
[17:29:24.324]                 is_error <- inherits(cond, "error")
[17:29:24.324]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:24.324]                   NULL)
[17:29:24.324]                 if (is_error) {
[17:29:24.324]                   sessionInformation <- function() {
[17:29:24.324]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:24.324]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:24.324]                       search = base::search(), system = base::Sys.info())
[17:29:24.324]                   }
[17:29:24.324]                   ...future.conditions[[length(...future.conditions) + 
[17:29:24.324]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:24.324]                     cond$call), session = sessionInformation(), 
[17:29:24.324]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:24.324]                   signalCondition(cond)
[17:29:24.324]                 }
[17:29:24.324]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:24.324]                 "immediateCondition"))) {
[17:29:24.324]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:24.324]                   ...future.conditions[[length(...future.conditions) + 
[17:29:24.324]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:24.324]                   if (TRUE && !signal) {
[17:29:24.324]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:24.324]                     {
[17:29:24.324]                       inherits <- base::inherits
[17:29:24.324]                       invokeRestart <- base::invokeRestart
[17:29:24.324]                       is.null <- base::is.null
[17:29:24.324]                       muffled <- FALSE
[17:29:24.324]                       if (inherits(cond, "message")) {
[17:29:24.324]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:24.324]                         if (muffled) 
[17:29:24.324]                           invokeRestart("muffleMessage")
[17:29:24.324]                       }
[17:29:24.324]                       else if (inherits(cond, "warning")) {
[17:29:24.324]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:24.324]                         if (muffled) 
[17:29:24.324]                           invokeRestart("muffleWarning")
[17:29:24.324]                       }
[17:29:24.324]                       else if (inherits(cond, "condition")) {
[17:29:24.324]                         if (!is.null(pattern)) {
[17:29:24.324]                           computeRestarts <- base::computeRestarts
[17:29:24.324]                           grepl <- base::grepl
[17:29:24.324]                           restarts <- computeRestarts(cond)
[17:29:24.324]                           for (restart in restarts) {
[17:29:24.324]                             name <- restart$name
[17:29:24.324]                             if (is.null(name)) 
[17:29:24.324]                               next
[17:29:24.324]                             if (!grepl(pattern, name)) 
[17:29:24.324]                               next
[17:29:24.324]                             invokeRestart(restart)
[17:29:24.324]                             muffled <- TRUE
[17:29:24.324]                             break
[17:29:24.324]                           }
[17:29:24.324]                         }
[17:29:24.324]                       }
[17:29:24.324]                       invisible(muffled)
[17:29:24.324]                     }
[17:29:24.324]                     muffleCondition(cond, pattern = "^muffle")
[17:29:24.324]                   }
[17:29:24.324]                 }
[17:29:24.324]                 else {
[17:29:24.324]                   if (TRUE) {
[17:29:24.324]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:24.324]                     {
[17:29:24.324]                       inherits <- base::inherits
[17:29:24.324]                       invokeRestart <- base::invokeRestart
[17:29:24.324]                       is.null <- base::is.null
[17:29:24.324]                       muffled <- FALSE
[17:29:24.324]                       if (inherits(cond, "message")) {
[17:29:24.324]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:24.324]                         if (muffled) 
[17:29:24.324]                           invokeRestart("muffleMessage")
[17:29:24.324]                       }
[17:29:24.324]                       else if (inherits(cond, "warning")) {
[17:29:24.324]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:24.324]                         if (muffled) 
[17:29:24.324]                           invokeRestart("muffleWarning")
[17:29:24.324]                       }
[17:29:24.324]                       else if (inherits(cond, "condition")) {
[17:29:24.324]                         if (!is.null(pattern)) {
[17:29:24.324]                           computeRestarts <- base::computeRestarts
[17:29:24.324]                           grepl <- base::grepl
[17:29:24.324]                           restarts <- computeRestarts(cond)
[17:29:24.324]                           for (restart in restarts) {
[17:29:24.324]                             name <- restart$name
[17:29:24.324]                             if (is.null(name)) 
[17:29:24.324]                               next
[17:29:24.324]                             if (!grepl(pattern, name)) 
[17:29:24.324]                               next
[17:29:24.324]                             invokeRestart(restart)
[17:29:24.324]                             muffled <- TRUE
[17:29:24.324]                             break
[17:29:24.324]                           }
[17:29:24.324]                         }
[17:29:24.324]                       }
[17:29:24.324]                       invisible(muffled)
[17:29:24.324]                     }
[17:29:24.324]                     muffleCondition(cond, pattern = "^muffle")
[17:29:24.324]                   }
[17:29:24.324]                 }
[17:29:24.324]             }
[17:29:24.324]         }))
[17:29:24.324]     }, error = function(ex) {
[17:29:24.324]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:24.324]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:24.324]                 ...future.rng), started = ...future.startTime, 
[17:29:24.324]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:24.324]             version = "1.8"), class = "FutureResult")
[17:29:24.324]     }, finally = {
[17:29:24.324]         if (!identical(...future.workdir, getwd())) 
[17:29:24.324]             setwd(...future.workdir)
[17:29:24.324]         {
[17:29:24.324]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:24.324]                 ...future.oldOptions$nwarnings <- NULL
[17:29:24.324]             }
[17:29:24.324]             base::options(...future.oldOptions)
[17:29:24.324]             if (.Platform$OS.type == "windows") {
[17:29:24.324]                 old_names <- names(...future.oldEnvVars)
[17:29:24.324]                 envs <- base::Sys.getenv()
[17:29:24.324]                 names <- names(envs)
[17:29:24.324]                 common <- intersect(names, old_names)
[17:29:24.324]                 added <- setdiff(names, old_names)
[17:29:24.324]                 removed <- setdiff(old_names, names)
[17:29:24.324]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:24.324]                   envs[common]]
[17:29:24.324]                 NAMES <- toupper(changed)
[17:29:24.324]                 args <- list()
[17:29:24.324]                 for (kk in seq_along(NAMES)) {
[17:29:24.324]                   name <- changed[[kk]]
[17:29:24.324]                   NAME <- NAMES[[kk]]
[17:29:24.324]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:24.324]                     next
[17:29:24.324]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:24.324]                 }
[17:29:24.324]                 NAMES <- toupper(added)
[17:29:24.324]                 for (kk in seq_along(NAMES)) {
[17:29:24.324]                   name <- added[[kk]]
[17:29:24.324]                   NAME <- NAMES[[kk]]
[17:29:24.324]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:24.324]                     next
[17:29:24.324]                   args[[name]] <- ""
[17:29:24.324]                 }
[17:29:24.324]                 NAMES <- toupper(removed)
[17:29:24.324]                 for (kk in seq_along(NAMES)) {
[17:29:24.324]                   name <- removed[[kk]]
[17:29:24.324]                   NAME <- NAMES[[kk]]
[17:29:24.324]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:24.324]                     next
[17:29:24.324]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:24.324]                 }
[17:29:24.324]                 if (length(args) > 0) 
[17:29:24.324]                   base::do.call(base::Sys.setenv, args = args)
[17:29:24.324]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:24.324]             }
[17:29:24.324]             else {
[17:29:24.324]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:24.324]             }
[17:29:24.324]             {
[17:29:24.324]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:24.324]                   0L) {
[17:29:24.324]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:24.324]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:24.324]                   base::options(opts)
[17:29:24.324]                 }
[17:29:24.324]                 {
[17:29:24.324]                   {
[17:29:24.324]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:24.324]                     NULL
[17:29:24.324]                   }
[17:29:24.324]                   options(future.plan = NULL)
[17:29:24.324]                   if (is.na(NA_character_)) 
[17:29:24.324]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:24.324]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:24.324]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:24.324]                     .init = FALSE)
[17:29:24.324]                 }
[17:29:24.324]             }
[17:29:24.324]         }
[17:29:24.324]     })
[17:29:24.324]     if (TRUE) {
[17:29:24.324]         base::sink(type = "output", split = FALSE)
[17:29:24.324]         if (TRUE) {
[17:29:24.324]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:24.324]         }
[17:29:24.324]         else {
[17:29:24.324]             ...future.result["stdout"] <- base::list(NULL)
[17:29:24.324]         }
[17:29:24.324]         base::close(...future.stdout)
[17:29:24.324]         ...future.stdout <- NULL
[17:29:24.324]     }
[17:29:24.324]     ...future.result$conditions <- ...future.conditions
[17:29:24.324]     ...future.result$finished <- base::Sys.time()
[17:29:24.324]     ...future.result
[17:29:24.324] }
[17:29:24.334] MultisessionFuture started
[17:29:24.334] - Launch lazy future ... done
[17:29:24.334] run() for 'MultisessionFuture' ... done
[17:29:24.358] receiveMessageFromWorker() for ClusterFuture ...
[17:29:24.359] - Validating connection of MultisessionFuture
[17:29:24.359] - received message: FutureResult
[17:29:24.360] - Received FutureResult
[17:29:24.360] - Erased future from FutureRegistry
[17:29:24.360] result() for ClusterFuture ...
[17:29:24.360] - result already collected: FutureResult
[17:29:24.361] result() for ClusterFuture ... done
[17:29:24.361] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:24.361] Future #2
[17:29:24.362]  length: 1 (resolved future 2)
[17:29:24.362]  length: 0 (resolved future 3)
[17:29:24.362] resolve() on list ... DONE
[17:29:24.362] getGlobalsAndPackages() ...
[17:29:24.363] Searching for globals...
[17:29:24.363] 
[17:29:24.364] Searching for globals ... DONE
[17:29:24.364] - globals: [0] <none>
[17:29:24.364] getGlobalsAndPackages() ... DONE
[17:29:24.365] run() for 'Future' ...
[17:29:24.365] - state: 'created'
[17:29:24.365] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:24.385] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:24.386] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:24.386]   - Field: 'node'
[17:29:24.386]   - Field: 'label'
[17:29:24.387]   - Field: 'local'
[17:29:24.387]   - Field: 'owner'
[17:29:24.387]   - Field: 'envir'
[17:29:24.388]   - Field: 'workers'
[17:29:24.388]   - Field: 'packages'
[17:29:24.388]   - Field: 'gc'
[17:29:24.388]   - Field: 'conditions'
[17:29:24.389]   - Field: 'persistent'
[17:29:24.389]   - Field: 'expr'
[17:29:24.389]   - Field: 'uuid'
[17:29:24.389]   - Field: 'seed'
[17:29:24.390]   - Field: 'version'
[17:29:24.390]   - Field: 'result'
[17:29:24.390]   - Field: 'asynchronous'
[17:29:24.391]   - Field: 'calls'
[17:29:24.391]   - Field: 'globals'
[17:29:24.391]   - Field: 'stdout'
[17:29:24.391]   - Field: 'earlySignal'
[17:29:24.392]   - Field: 'lazy'
[17:29:24.392]   - Field: 'state'
[17:29:24.392] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:24.393] - Launch lazy future ...
[17:29:24.393] Packages needed by the future expression (n = 0): <none>
[17:29:24.393] Packages needed by future strategies (n = 0): <none>
[17:29:24.394] {
[17:29:24.394]     {
[17:29:24.394]         {
[17:29:24.394]             ...future.startTime <- base::Sys.time()
[17:29:24.394]             {
[17:29:24.394]                 {
[17:29:24.394]                   {
[17:29:24.394]                     {
[17:29:24.394]                       base::local({
[17:29:24.394]                         has_future <- base::requireNamespace("future", 
[17:29:24.394]                           quietly = TRUE)
[17:29:24.394]                         if (has_future) {
[17:29:24.394]                           ns <- base::getNamespace("future")
[17:29:24.394]                           version <- ns[[".package"]][["version"]]
[17:29:24.394]                           if (is.null(version)) 
[17:29:24.394]                             version <- utils::packageVersion("future")
[17:29:24.394]                         }
[17:29:24.394]                         else {
[17:29:24.394]                           version <- NULL
[17:29:24.394]                         }
[17:29:24.394]                         if (!has_future || version < "1.8.0") {
[17:29:24.394]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:24.394]                             "", base::R.version$version.string), 
[17:29:24.394]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:24.394]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:24.394]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:24.394]                               "release", "version")], collapse = " "), 
[17:29:24.394]                             hostname = base::Sys.info()[["nodename"]])
[17:29:24.394]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:24.394]                             info)
[17:29:24.394]                           info <- base::paste(info, collapse = "; ")
[17:29:24.394]                           if (!has_future) {
[17:29:24.394]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:24.394]                               info)
[17:29:24.394]                           }
[17:29:24.394]                           else {
[17:29:24.394]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:24.394]                               info, version)
[17:29:24.394]                           }
[17:29:24.394]                           base::stop(msg)
[17:29:24.394]                         }
[17:29:24.394]                       })
[17:29:24.394]                     }
[17:29:24.394]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:24.394]                     base::options(mc.cores = 1L)
[17:29:24.394]                   }
[17:29:24.394]                   ...future.strategy.old <- future::plan("list")
[17:29:24.394]                   options(future.plan = NULL)
[17:29:24.394]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:24.394]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:24.394]                 }
[17:29:24.394]                 ...future.workdir <- getwd()
[17:29:24.394]             }
[17:29:24.394]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:24.394]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:24.394]         }
[17:29:24.394]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:24.394]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:24.394]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:24.394]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:24.394]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:24.394]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:24.394]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:24.394]             base::names(...future.oldOptions))
[17:29:24.394]     }
[17:29:24.394]     if (FALSE) {
[17:29:24.394]     }
[17:29:24.394]     else {
[17:29:24.394]         if (TRUE) {
[17:29:24.394]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:24.394]                 open = "w")
[17:29:24.394]         }
[17:29:24.394]         else {
[17:29:24.394]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:24.394]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:24.394]         }
[17:29:24.394]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:24.394]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:24.394]             base::sink(type = "output", split = FALSE)
[17:29:24.394]             base::close(...future.stdout)
[17:29:24.394]         }, add = TRUE)
[17:29:24.394]     }
[17:29:24.394]     ...future.frame <- base::sys.nframe()
[17:29:24.394]     ...future.conditions <- base::list()
[17:29:24.394]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:24.394]     if (FALSE) {
[17:29:24.394]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:24.394]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:24.394]     }
[17:29:24.394]     ...future.result <- base::tryCatch({
[17:29:24.394]         base::withCallingHandlers({
[17:29:24.394]             ...future.value <- base::withVisible(base::local({
[17:29:24.394]                 ...future.makeSendCondition <- base::local({
[17:29:24.394]                   sendCondition <- NULL
[17:29:24.394]                   function(frame = 1L) {
[17:29:24.394]                     if (is.function(sendCondition)) 
[17:29:24.394]                       return(sendCondition)
[17:29:24.394]                     ns <- getNamespace("parallel")
[17:29:24.394]                     if (exists("sendData", mode = "function", 
[17:29:24.394]                       envir = ns)) {
[17:29:24.394]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:24.394]                         envir = ns)
[17:29:24.394]                       envir <- sys.frame(frame)
[17:29:24.394]                       master <- NULL
[17:29:24.394]                       while (!identical(envir, .GlobalEnv) && 
[17:29:24.394]                         !identical(envir, emptyenv())) {
[17:29:24.394]                         if (exists("master", mode = "list", envir = envir, 
[17:29:24.394]                           inherits = FALSE)) {
[17:29:24.394]                           master <- get("master", mode = "list", 
[17:29:24.394]                             envir = envir, inherits = FALSE)
[17:29:24.394]                           if (inherits(master, c("SOCKnode", 
[17:29:24.394]                             "SOCK0node"))) {
[17:29:24.394]                             sendCondition <<- function(cond) {
[17:29:24.394]                               data <- list(type = "VALUE", value = cond, 
[17:29:24.394]                                 success = TRUE)
[17:29:24.394]                               parallel_sendData(master, data)
[17:29:24.394]                             }
[17:29:24.394]                             return(sendCondition)
[17:29:24.394]                           }
[17:29:24.394]                         }
[17:29:24.394]                         frame <- frame + 1L
[17:29:24.394]                         envir <- sys.frame(frame)
[17:29:24.394]                       }
[17:29:24.394]                     }
[17:29:24.394]                     sendCondition <<- function(cond) NULL
[17:29:24.394]                   }
[17:29:24.394]                 })
[17:29:24.394]                 withCallingHandlers({
[17:29:24.394]                   1
[17:29:24.394]                 }, immediateCondition = function(cond) {
[17:29:24.394]                   sendCondition <- ...future.makeSendCondition()
[17:29:24.394]                   sendCondition(cond)
[17:29:24.394]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:24.394]                   {
[17:29:24.394]                     inherits <- base::inherits
[17:29:24.394]                     invokeRestart <- base::invokeRestart
[17:29:24.394]                     is.null <- base::is.null
[17:29:24.394]                     muffled <- FALSE
[17:29:24.394]                     if (inherits(cond, "message")) {
[17:29:24.394]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:24.394]                       if (muffled) 
[17:29:24.394]                         invokeRestart("muffleMessage")
[17:29:24.394]                     }
[17:29:24.394]                     else if (inherits(cond, "warning")) {
[17:29:24.394]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:24.394]                       if (muffled) 
[17:29:24.394]                         invokeRestart("muffleWarning")
[17:29:24.394]                     }
[17:29:24.394]                     else if (inherits(cond, "condition")) {
[17:29:24.394]                       if (!is.null(pattern)) {
[17:29:24.394]                         computeRestarts <- base::computeRestarts
[17:29:24.394]                         grepl <- base::grepl
[17:29:24.394]                         restarts <- computeRestarts(cond)
[17:29:24.394]                         for (restart in restarts) {
[17:29:24.394]                           name <- restart$name
[17:29:24.394]                           if (is.null(name)) 
[17:29:24.394]                             next
[17:29:24.394]                           if (!grepl(pattern, name)) 
[17:29:24.394]                             next
[17:29:24.394]                           invokeRestart(restart)
[17:29:24.394]                           muffled <- TRUE
[17:29:24.394]                           break
[17:29:24.394]                         }
[17:29:24.394]                       }
[17:29:24.394]                     }
[17:29:24.394]                     invisible(muffled)
[17:29:24.394]                   }
[17:29:24.394]                   muffleCondition(cond)
[17:29:24.394]                 })
[17:29:24.394]             }))
[17:29:24.394]             future::FutureResult(value = ...future.value$value, 
[17:29:24.394]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:24.394]                   ...future.rng), globalenv = if (FALSE) 
[17:29:24.394]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:24.394]                     ...future.globalenv.names))
[17:29:24.394]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:24.394]         }, condition = base::local({
[17:29:24.394]             c <- base::c
[17:29:24.394]             inherits <- base::inherits
[17:29:24.394]             invokeRestart <- base::invokeRestart
[17:29:24.394]             length <- base::length
[17:29:24.394]             list <- base::list
[17:29:24.394]             seq.int <- base::seq.int
[17:29:24.394]             signalCondition <- base::signalCondition
[17:29:24.394]             sys.calls <- base::sys.calls
[17:29:24.394]             `[[` <- base::`[[`
[17:29:24.394]             `+` <- base::`+`
[17:29:24.394]             `<<-` <- base::`<<-`
[17:29:24.394]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:24.394]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:24.394]                   3L)]
[17:29:24.394]             }
[17:29:24.394]             function(cond) {
[17:29:24.394]                 is_error <- inherits(cond, "error")
[17:29:24.394]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:24.394]                   NULL)
[17:29:24.394]                 if (is_error) {
[17:29:24.394]                   sessionInformation <- function() {
[17:29:24.394]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:24.394]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:24.394]                       search = base::search(), system = base::Sys.info())
[17:29:24.394]                   }
[17:29:24.394]                   ...future.conditions[[length(...future.conditions) + 
[17:29:24.394]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:24.394]                     cond$call), session = sessionInformation(), 
[17:29:24.394]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:24.394]                   signalCondition(cond)
[17:29:24.394]                 }
[17:29:24.394]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:24.394]                 "immediateCondition"))) {
[17:29:24.394]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:24.394]                   ...future.conditions[[length(...future.conditions) + 
[17:29:24.394]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:24.394]                   if (TRUE && !signal) {
[17:29:24.394]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:24.394]                     {
[17:29:24.394]                       inherits <- base::inherits
[17:29:24.394]                       invokeRestart <- base::invokeRestart
[17:29:24.394]                       is.null <- base::is.null
[17:29:24.394]                       muffled <- FALSE
[17:29:24.394]                       if (inherits(cond, "message")) {
[17:29:24.394]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:24.394]                         if (muffled) 
[17:29:24.394]                           invokeRestart("muffleMessage")
[17:29:24.394]                       }
[17:29:24.394]                       else if (inherits(cond, "warning")) {
[17:29:24.394]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:24.394]                         if (muffled) 
[17:29:24.394]                           invokeRestart("muffleWarning")
[17:29:24.394]                       }
[17:29:24.394]                       else if (inherits(cond, "condition")) {
[17:29:24.394]                         if (!is.null(pattern)) {
[17:29:24.394]                           computeRestarts <- base::computeRestarts
[17:29:24.394]                           grepl <- base::grepl
[17:29:24.394]                           restarts <- computeRestarts(cond)
[17:29:24.394]                           for (restart in restarts) {
[17:29:24.394]                             name <- restart$name
[17:29:24.394]                             if (is.null(name)) 
[17:29:24.394]                               next
[17:29:24.394]                             if (!grepl(pattern, name)) 
[17:29:24.394]                               next
[17:29:24.394]                             invokeRestart(restart)
[17:29:24.394]                             muffled <- TRUE
[17:29:24.394]                             break
[17:29:24.394]                           }
[17:29:24.394]                         }
[17:29:24.394]                       }
[17:29:24.394]                       invisible(muffled)
[17:29:24.394]                     }
[17:29:24.394]                     muffleCondition(cond, pattern = "^muffle")
[17:29:24.394]                   }
[17:29:24.394]                 }
[17:29:24.394]                 else {
[17:29:24.394]                   if (TRUE) {
[17:29:24.394]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:24.394]                     {
[17:29:24.394]                       inherits <- base::inherits
[17:29:24.394]                       invokeRestart <- base::invokeRestart
[17:29:24.394]                       is.null <- base::is.null
[17:29:24.394]                       muffled <- FALSE
[17:29:24.394]                       if (inherits(cond, "message")) {
[17:29:24.394]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:24.394]                         if (muffled) 
[17:29:24.394]                           invokeRestart("muffleMessage")
[17:29:24.394]                       }
[17:29:24.394]                       else if (inherits(cond, "warning")) {
[17:29:24.394]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:24.394]                         if (muffled) 
[17:29:24.394]                           invokeRestart("muffleWarning")
[17:29:24.394]                       }
[17:29:24.394]                       else if (inherits(cond, "condition")) {
[17:29:24.394]                         if (!is.null(pattern)) {
[17:29:24.394]                           computeRestarts <- base::computeRestarts
[17:29:24.394]                           grepl <- base::grepl
[17:29:24.394]                           restarts <- computeRestarts(cond)
[17:29:24.394]                           for (restart in restarts) {
[17:29:24.394]                             name <- restart$name
[17:29:24.394]                             if (is.null(name)) 
[17:29:24.394]                               next
[17:29:24.394]                             if (!grepl(pattern, name)) 
[17:29:24.394]                               next
[17:29:24.394]                             invokeRestart(restart)
[17:29:24.394]                             muffled <- TRUE
[17:29:24.394]                             break
[17:29:24.394]                           }
[17:29:24.394]                         }
[17:29:24.394]                       }
[17:29:24.394]                       invisible(muffled)
[17:29:24.394]                     }
[17:29:24.394]                     muffleCondition(cond, pattern = "^muffle")
[17:29:24.394]                   }
[17:29:24.394]                 }
[17:29:24.394]             }
[17:29:24.394]         }))
[17:29:24.394]     }, error = function(ex) {
[17:29:24.394]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:24.394]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:24.394]                 ...future.rng), started = ...future.startTime, 
[17:29:24.394]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:24.394]             version = "1.8"), class = "FutureResult")
[17:29:24.394]     }, finally = {
[17:29:24.394]         if (!identical(...future.workdir, getwd())) 
[17:29:24.394]             setwd(...future.workdir)
[17:29:24.394]         {
[17:29:24.394]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:24.394]                 ...future.oldOptions$nwarnings <- NULL
[17:29:24.394]             }
[17:29:24.394]             base::options(...future.oldOptions)
[17:29:24.394]             if (.Platform$OS.type == "windows") {
[17:29:24.394]                 old_names <- names(...future.oldEnvVars)
[17:29:24.394]                 envs <- base::Sys.getenv()
[17:29:24.394]                 names <- names(envs)
[17:29:24.394]                 common <- intersect(names, old_names)
[17:29:24.394]                 added <- setdiff(names, old_names)
[17:29:24.394]                 removed <- setdiff(old_names, names)
[17:29:24.394]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:24.394]                   envs[common]]
[17:29:24.394]                 NAMES <- toupper(changed)
[17:29:24.394]                 args <- list()
[17:29:24.394]                 for (kk in seq_along(NAMES)) {
[17:29:24.394]                   name <- changed[[kk]]
[17:29:24.394]                   NAME <- NAMES[[kk]]
[17:29:24.394]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:24.394]                     next
[17:29:24.394]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:24.394]                 }
[17:29:24.394]                 NAMES <- toupper(added)
[17:29:24.394]                 for (kk in seq_along(NAMES)) {
[17:29:24.394]                   name <- added[[kk]]
[17:29:24.394]                   NAME <- NAMES[[kk]]
[17:29:24.394]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:24.394]                     next
[17:29:24.394]                   args[[name]] <- ""
[17:29:24.394]                 }
[17:29:24.394]                 NAMES <- toupper(removed)
[17:29:24.394]                 for (kk in seq_along(NAMES)) {
[17:29:24.394]                   name <- removed[[kk]]
[17:29:24.394]                   NAME <- NAMES[[kk]]
[17:29:24.394]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:24.394]                     next
[17:29:24.394]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:24.394]                 }
[17:29:24.394]                 if (length(args) > 0) 
[17:29:24.394]                   base::do.call(base::Sys.setenv, args = args)
[17:29:24.394]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:24.394]             }
[17:29:24.394]             else {
[17:29:24.394]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:24.394]             }
[17:29:24.394]             {
[17:29:24.394]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:24.394]                   0L) {
[17:29:24.394]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:24.394]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:24.394]                   base::options(opts)
[17:29:24.394]                 }
[17:29:24.394]                 {
[17:29:24.394]                   {
[17:29:24.394]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:24.394]                     NULL
[17:29:24.394]                   }
[17:29:24.394]                   options(future.plan = NULL)
[17:29:24.394]                   if (is.na(NA_character_)) 
[17:29:24.394]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:24.394]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:24.394]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:24.394]                     .init = FALSE)
[17:29:24.394]                 }
[17:29:24.394]             }
[17:29:24.394]         }
[17:29:24.394]     })
[17:29:24.394]     if (TRUE) {
[17:29:24.394]         base::sink(type = "output", split = FALSE)
[17:29:24.394]         if (TRUE) {
[17:29:24.394]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:24.394]         }
[17:29:24.394]         else {
[17:29:24.394]             ...future.result["stdout"] <- base::list(NULL)
[17:29:24.394]         }
[17:29:24.394]         base::close(...future.stdout)
[17:29:24.394]         ...future.stdout <- NULL
[17:29:24.394]     }
[17:29:24.394]     ...future.result$conditions <- ...future.conditions
[17:29:24.394]     ...future.result$finished <- base::Sys.time()
[17:29:24.394]     ...future.result
[17:29:24.394] }
[17:29:24.403] MultisessionFuture started
[17:29:24.403] - Launch lazy future ... done
[17:29:24.404] run() for 'MultisessionFuture' ... done
[17:29:24.404] getGlobalsAndPackages() ...
[17:29:24.404] Searching for globals...
[17:29:24.406] - globals found: [2] '{', 'Sys.sleep'
[17:29:24.406] Searching for globals ... DONE
[17:29:24.407] Resolving globals: FALSE
[17:29:24.407] 
[17:29:24.408] 
[17:29:24.408] getGlobalsAndPackages() ... DONE
[17:29:24.408] run() for 'Future' ...
[17:29:24.409] - state: 'created'
[17:29:24.409] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:24.429] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:24.429] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:24.429]   - Field: 'node'
[17:29:24.430]   - Field: 'label'
[17:29:24.430]   - Field: 'local'
[17:29:24.430]   - Field: 'owner'
[17:29:24.431]   - Field: 'envir'
[17:29:24.431]   - Field: 'workers'
[17:29:24.431]   - Field: 'packages'
[17:29:24.432]   - Field: 'gc'
[17:29:24.432]   - Field: 'conditions'
[17:29:24.432]   - Field: 'persistent'
[17:29:24.432]   - Field: 'expr'
[17:29:24.433]   - Field: 'uuid'
[17:29:24.433]   - Field: 'seed'
[17:29:24.433]   - Field: 'version'
[17:29:24.433]   - Field: 'result'
[17:29:24.434]   - Field: 'asynchronous'
[17:29:24.434]   - Field: 'calls'
[17:29:24.434]   - Field: 'globals'
[17:29:24.434]   - Field: 'stdout'
[17:29:24.435]   - Field: 'earlySignal'
[17:29:24.435]   - Field: 'lazy'
[17:29:24.435]   - Field: 'state'
[17:29:24.435] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:24.436] - Launch lazy future ...
[17:29:24.436] Packages needed by the future expression (n = 0): <none>
[17:29:24.437] Packages needed by future strategies (n = 0): <none>
[17:29:24.442] {
[17:29:24.442]     {
[17:29:24.442]         {
[17:29:24.442]             ...future.startTime <- base::Sys.time()
[17:29:24.442]             {
[17:29:24.442]                 {
[17:29:24.442]                   {
[17:29:24.442]                     {
[17:29:24.442]                       base::local({
[17:29:24.442]                         has_future <- base::requireNamespace("future", 
[17:29:24.442]                           quietly = TRUE)
[17:29:24.442]                         if (has_future) {
[17:29:24.442]                           ns <- base::getNamespace("future")
[17:29:24.442]                           version <- ns[[".package"]][["version"]]
[17:29:24.442]                           if (is.null(version)) 
[17:29:24.442]                             version <- utils::packageVersion("future")
[17:29:24.442]                         }
[17:29:24.442]                         else {
[17:29:24.442]                           version <- NULL
[17:29:24.442]                         }
[17:29:24.442]                         if (!has_future || version < "1.8.0") {
[17:29:24.442]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:24.442]                             "", base::R.version$version.string), 
[17:29:24.442]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:24.442]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:24.442]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:24.442]                               "release", "version")], collapse = " "), 
[17:29:24.442]                             hostname = base::Sys.info()[["nodename"]])
[17:29:24.442]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:24.442]                             info)
[17:29:24.442]                           info <- base::paste(info, collapse = "; ")
[17:29:24.442]                           if (!has_future) {
[17:29:24.442]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:24.442]                               info)
[17:29:24.442]                           }
[17:29:24.442]                           else {
[17:29:24.442]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:24.442]                               info, version)
[17:29:24.442]                           }
[17:29:24.442]                           base::stop(msg)
[17:29:24.442]                         }
[17:29:24.442]                       })
[17:29:24.442]                     }
[17:29:24.442]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:24.442]                     base::options(mc.cores = 1L)
[17:29:24.442]                   }
[17:29:24.442]                   ...future.strategy.old <- future::plan("list")
[17:29:24.442]                   options(future.plan = NULL)
[17:29:24.442]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:24.442]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:24.442]                 }
[17:29:24.442]                 ...future.workdir <- getwd()
[17:29:24.442]             }
[17:29:24.442]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:24.442]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:24.442]         }
[17:29:24.442]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:24.442]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:24.442]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:24.442]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:24.442]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:24.442]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:24.442]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:24.442]             base::names(...future.oldOptions))
[17:29:24.442]     }
[17:29:24.442]     if (FALSE) {
[17:29:24.442]     }
[17:29:24.442]     else {
[17:29:24.442]         if (TRUE) {
[17:29:24.442]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:24.442]                 open = "w")
[17:29:24.442]         }
[17:29:24.442]         else {
[17:29:24.442]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:24.442]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:24.442]         }
[17:29:24.442]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:24.442]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:24.442]             base::sink(type = "output", split = FALSE)
[17:29:24.442]             base::close(...future.stdout)
[17:29:24.442]         }, add = TRUE)
[17:29:24.442]     }
[17:29:24.442]     ...future.frame <- base::sys.nframe()
[17:29:24.442]     ...future.conditions <- base::list()
[17:29:24.442]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:24.442]     if (FALSE) {
[17:29:24.442]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:24.442]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:24.442]     }
[17:29:24.442]     ...future.result <- base::tryCatch({
[17:29:24.442]         base::withCallingHandlers({
[17:29:24.442]             ...future.value <- base::withVisible(base::local({
[17:29:24.442]                 ...future.makeSendCondition <- base::local({
[17:29:24.442]                   sendCondition <- NULL
[17:29:24.442]                   function(frame = 1L) {
[17:29:24.442]                     if (is.function(sendCondition)) 
[17:29:24.442]                       return(sendCondition)
[17:29:24.442]                     ns <- getNamespace("parallel")
[17:29:24.442]                     if (exists("sendData", mode = "function", 
[17:29:24.442]                       envir = ns)) {
[17:29:24.442]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:24.442]                         envir = ns)
[17:29:24.442]                       envir <- sys.frame(frame)
[17:29:24.442]                       master <- NULL
[17:29:24.442]                       while (!identical(envir, .GlobalEnv) && 
[17:29:24.442]                         !identical(envir, emptyenv())) {
[17:29:24.442]                         if (exists("master", mode = "list", envir = envir, 
[17:29:24.442]                           inherits = FALSE)) {
[17:29:24.442]                           master <- get("master", mode = "list", 
[17:29:24.442]                             envir = envir, inherits = FALSE)
[17:29:24.442]                           if (inherits(master, c("SOCKnode", 
[17:29:24.442]                             "SOCK0node"))) {
[17:29:24.442]                             sendCondition <<- function(cond) {
[17:29:24.442]                               data <- list(type = "VALUE", value = cond, 
[17:29:24.442]                                 success = TRUE)
[17:29:24.442]                               parallel_sendData(master, data)
[17:29:24.442]                             }
[17:29:24.442]                             return(sendCondition)
[17:29:24.442]                           }
[17:29:24.442]                         }
[17:29:24.442]                         frame <- frame + 1L
[17:29:24.442]                         envir <- sys.frame(frame)
[17:29:24.442]                       }
[17:29:24.442]                     }
[17:29:24.442]                     sendCondition <<- function(cond) NULL
[17:29:24.442]                   }
[17:29:24.442]                 })
[17:29:24.442]                 withCallingHandlers({
[17:29:24.442]                   {
[17:29:24.442]                     Sys.sleep(0.5)
[17:29:24.442]                     2
[17:29:24.442]                   }
[17:29:24.442]                 }, immediateCondition = function(cond) {
[17:29:24.442]                   sendCondition <- ...future.makeSendCondition()
[17:29:24.442]                   sendCondition(cond)
[17:29:24.442]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:24.442]                   {
[17:29:24.442]                     inherits <- base::inherits
[17:29:24.442]                     invokeRestart <- base::invokeRestart
[17:29:24.442]                     is.null <- base::is.null
[17:29:24.442]                     muffled <- FALSE
[17:29:24.442]                     if (inherits(cond, "message")) {
[17:29:24.442]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:24.442]                       if (muffled) 
[17:29:24.442]                         invokeRestart("muffleMessage")
[17:29:24.442]                     }
[17:29:24.442]                     else if (inherits(cond, "warning")) {
[17:29:24.442]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:24.442]                       if (muffled) 
[17:29:24.442]                         invokeRestart("muffleWarning")
[17:29:24.442]                     }
[17:29:24.442]                     else if (inherits(cond, "condition")) {
[17:29:24.442]                       if (!is.null(pattern)) {
[17:29:24.442]                         computeRestarts <- base::computeRestarts
[17:29:24.442]                         grepl <- base::grepl
[17:29:24.442]                         restarts <- computeRestarts(cond)
[17:29:24.442]                         for (restart in restarts) {
[17:29:24.442]                           name <- restart$name
[17:29:24.442]                           if (is.null(name)) 
[17:29:24.442]                             next
[17:29:24.442]                           if (!grepl(pattern, name)) 
[17:29:24.442]                             next
[17:29:24.442]                           invokeRestart(restart)
[17:29:24.442]                           muffled <- TRUE
[17:29:24.442]                           break
[17:29:24.442]                         }
[17:29:24.442]                       }
[17:29:24.442]                     }
[17:29:24.442]                     invisible(muffled)
[17:29:24.442]                   }
[17:29:24.442]                   muffleCondition(cond)
[17:29:24.442]                 })
[17:29:24.442]             }))
[17:29:24.442]             future::FutureResult(value = ...future.value$value, 
[17:29:24.442]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:24.442]                   ...future.rng), globalenv = if (FALSE) 
[17:29:24.442]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:24.442]                     ...future.globalenv.names))
[17:29:24.442]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:24.442]         }, condition = base::local({
[17:29:24.442]             c <- base::c
[17:29:24.442]             inherits <- base::inherits
[17:29:24.442]             invokeRestart <- base::invokeRestart
[17:29:24.442]             length <- base::length
[17:29:24.442]             list <- base::list
[17:29:24.442]             seq.int <- base::seq.int
[17:29:24.442]             signalCondition <- base::signalCondition
[17:29:24.442]             sys.calls <- base::sys.calls
[17:29:24.442]             `[[` <- base::`[[`
[17:29:24.442]             `+` <- base::`+`
[17:29:24.442]             `<<-` <- base::`<<-`
[17:29:24.442]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:24.442]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:24.442]                   3L)]
[17:29:24.442]             }
[17:29:24.442]             function(cond) {
[17:29:24.442]                 is_error <- inherits(cond, "error")
[17:29:24.442]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:24.442]                   NULL)
[17:29:24.442]                 if (is_error) {
[17:29:24.442]                   sessionInformation <- function() {
[17:29:24.442]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:24.442]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:24.442]                       search = base::search(), system = base::Sys.info())
[17:29:24.442]                   }
[17:29:24.442]                   ...future.conditions[[length(...future.conditions) + 
[17:29:24.442]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:24.442]                     cond$call), session = sessionInformation(), 
[17:29:24.442]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:24.442]                   signalCondition(cond)
[17:29:24.442]                 }
[17:29:24.442]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:24.442]                 "immediateCondition"))) {
[17:29:24.442]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:24.442]                   ...future.conditions[[length(...future.conditions) + 
[17:29:24.442]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:24.442]                   if (TRUE && !signal) {
[17:29:24.442]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:24.442]                     {
[17:29:24.442]                       inherits <- base::inherits
[17:29:24.442]                       invokeRestart <- base::invokeRestart
[17:29:24.442]                       is.null <- base::is.null
[17:29:24.442]                       muffled <- FALSE
[17:29:24.442]                       if (inherits(cond, "message")) {
[17:29:24.442]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:24.442]                         if (muffled) 
[17:29:24.442]                           invokeRestart("muffleMessage")
[17:29:24.442]                       }
[17:29:24.442]                       else if (inherits(cond, "warning")) {
[17:29:24.442]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:24.442]                         if (muffled) 
[17:29:24.442]                           invokeRestart("muffleWarning")
[17:29:24.442]                       }
[17:29:24.442]                       else if (inherits(cond, "condition")) {
[17:29:24.442]                         if (!is.null(pattern)) {
[17:29:24.442]                           computeRestarts <- base::computeRestarts
[17:29:24.442]                           grepl <- base::grepl
[17:29:24.442]                           restarts <- computeRestarts(cond)
[17:29:24.442]                           for (restart in restarts) {
[17:29:24.442]                             name <- restart$name
[17:29:24.442]                             if (is.null(name)) 
[17:29:24.442]                               next
[17:29:24.442]                             if (!grepl(pattern, name)) 
[17:29:24.442]                               next
[17:29:24.442]                             invokeRestart(restart)
[17:29:24.442]                             muffled <- TRUE
[17:29:24.442]                             break
[17:29:24.442]                           }
[17:29:24.442]                         }
[17:29:24.442]                       }
[17:29:24.442]                       invisible(muffled)
[17:29:24.442]                     }
[17:29:24.442]                     muffleCondition(cond, pattern = "^muffle")
[17:29:24.442]                   }
[17:29:24.442]                 }
[17:29:24.442]                 else {
[17:29:24.442]                   if (TRUE) {
[17:29:24.442]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:24.442]                     {
[17:29:24.442]                       inherits <- base::inherits
[17:29:24.442]                       invokeRestart <- base::invokeRestart
[17:29:24.442]                       is.null <- base::is.null
[17:29:24.442]                       muffled <- FALSE
[17:29:24.442]                       if (inherits(cond, "message")) {
[17:29:24.442]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:24.442]                         if (muffled) 
[17:29:24.442]                           invokeRestart("muffleMessage")
[17:29:24.442]                       }
[17:29:24.442]                       else if (inherits(cond, "warning")) {
[17:29:24.442]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:24.442]                         if (muffled) 
[17:29:24.442]                           invokeRestart("muffleWarning")
[17:29:24.442]                       }
[17:29:24.442]                       else if (inherits(cond, "condition")) {
[17:29:24.442]                         if (!is.null(pattern)) {
[17:29:24.442]                           computeRestarts <- base::computeRestarts
[17:29:24.442]                           grepl <- base::grepl
[17:29:24.442]                           restarts <- computeRestarts(cond)
[17:29:24.442]                           for (restart in restarts) {
[17:29:24.442]                             name <- restart$name
[17:29:24.442]                             if (is.null(name)) 
[17:29:24.442]                               next
[17:29:24.442]                             if (!grepl(pattern, name)) 
[17:29:24.442]                               next
[17:29:24.442]                             invokeRestart(restart)
[17:29:24.442]                             muffled <- TRUE
[17:29:24.442]                             break
[17:29:24.442]                           }
[17:29:24.442]                         }
[17:29:24.442]                       }
[17:29:24.442]                       invisible(muffled)
[17:29:24.442]                     }
[17:29:24.442]                     muffleCondition(cond, pattern = "^muffle")
[17:29:24.442]                   }
[17:29:24.442]                 }
[17:29:24.442]             }
[17:29:24.442]         }))
[17:29:24.442]     }, error = function(ex) {
[17:29:24.442]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:24.442]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:24.442]                 ...future.rng), started = ...future.startTime, 
[17:29:24.442]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:24.442]             version = "1.8"), class = "FutureResult")
[17:29:24.442]     }, finally = {
[17:29:24.442]         if (!identical(...future.workdir, getwd())) 
[17:29:24.442]             setwd(...future.workdir)
[17:29:24.442]         {
[17:29:24.442]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:24.442]                 ...future.oldOptions$nwarnings <- NULL
[17:29:24.442]             }
[17:29:24.442]             base::options(...future.oldOptions)
[17:29:24.442]             if (.Platform$OS.type == "windows") {
[17:29:24.442]                 old_names <- names(...future.oldEnvVars)
[17:29:24.442]                 envs <- base::Sys.getenv()
[17:29:24.442]                 names <- names(envs)
[17:29:24.442]                 common <- intersect(names, old_names)
[17:29:24.442]                 added <- setdiff(names, old_names)
[17:29:24.442]                 removed <- setdiff(old_names, names)
[17:29:24.442]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:24.442]                   envs[common]]
[17:29:24.442]                 NAMES <- toupper(changed)
[17:29:24.442]                 args <- list()
[17:29:24.442]                 for (kk in seq_along(NAMES)) {
[17:29:24.442]                   name <- changed[[kk]]
[17:29:24.442]                   NAME <- NAMES[[kk]]
[17:29:24.442]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:24.442]                     next
[17:29:24.442]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:24.442]                 }
[17:29:24.442]                 NAMES <- toupper(added)
[17:29:24.442]                 for (kk in seq_along(NAMES)) {
[17:29:24.442]                   name <- added[[kk]]
[17:29:24.442]                   NAME <- NAMES[[kk]]
[17:29:24.442]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:24.442]                     next
[17:29:24.442]                   args[[name]] <- ""
[17:29:24.442]                 }
[17:29:24.442]                 NAMES <- toupper(removed)
[17:29:24.442]                 for (kk in seq_along(NAMES)) {
[17:29:24.442]                   name <- removed[[kk]]
[17:29:24.442]                   NAME <- NAMES[[kk]]
[17:29:24.442]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:24.442]                     next
[17:29:24.442]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:24.442]                 }
[17:29:24.442]                 if (length(args) > 0) 
[17:29:24.442]                   base::do.call(base::Sys.setenv, args = args)
[17:29:24.442]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:24.442]             }
[17:29:24.442]             else {
[17:29:24.442]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:24.442]             }
[17:29:24.442]             {
[17:29:24.442]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:24.442]                   0L) {
[17:29:24.442]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:24.442]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:24.442]                   base::options(opts)
[17:29:24.442]                 }
[17:29:24.442]                 {
[17:29:24.442]                   {
[17:29:24.442]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:24.442]                     NULL
[17:29:24.442]                   }
[17:29:24.442]                   options(future.plan = NULL)
[17:29:24.442]                   if (is.na(NA_character_)) 
[17:29:24.442]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:24.442]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:24.442]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:24.442]                     .init = FALSE)
[17:29:24.442]                 }
[17:29:24.442]             }
[17:29:24.442]         }
[17:29:24.442]     })
[17:29:24.442]     if (TRUE) {
[17:29:24.442]         base::sink(type = "output", split = FALSE)
[17:29:24.442]         if (TRUE) {
[17:29:24.442]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:24.442]         }
[17:29:24.442]         else {
[17:29:24.442]             ...future.result["stdout"] <- base::list(NULL)
[17:29:24.442]         }
[17:29:24.442]         base::close(...future.stdout)
[17:29:24.442]         ...future.stdout <- NULL
[17:29:24.442]     }
[17:29:24.442]     ...future.result$conditions <- ...future.conditions
[17:29:24.442]     ...future.result$finished <- base::Sys.time()
[17:29:24.442]     ...future.result
[17:29:24.442] }
[17:29:24.451] MultisessionFuture started
[17:29:24.451] - Launch lazy future ... done
[17:29:24.451] run() for 'MultisessionFuture' ... done
[17:29:24.452] resolve() on list ...
[17:29:24.452]  recursive: 0
[17:29:24.453]  length: 1
[17:29:24.453] 
[17:29:24.454] receiveMessageFromWorker() for ClusterFuture ...
[17:29:24.454] - Validating connection of MultisessionFuture
[17:29:24.454] - received message: FutureResult
[17:29:24.455] - Received FutureResult
[17:29:24.455] - Erased future from FutureRegistry
[17:29:24.455] result() for ClusterFuture ...
[17:29:24.456] - result already collected: FutureResult
[17:29:24.456] result() for ClusterFuture ... done
[17:29:24.456] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:24.457] Future #1
[17:29:24.457]  length: 0 (resolved future 1)
[17:29:24.457] resolve() on list ... DONE
[17:29:24.458] resolve() on list ...
[17:29:24.458]  recursive: 0
[17:29:24.458]  length: 1
[17:29:24.458] 
[17:29:24.983] receiveMessageFromWorker() for ClusterFuture ...
[17:29:24.983] - Validating connection of MultisessionFuture
[17:29:24.984] - received message: FutureResult
[17:29:24.984] - Received FutureResult
[17:29:24.984] - Erased future from FutureRegistry
[17:29:24.985] result() for ClusterFuture ...
[17:29:24.985] - result already collected: FutureResult
[17:29:24.985] result() for ClusterFuture ... done
[17:29:24.985] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:24.986] Future #1
[17:29:24.986]  length: 0 (resolved future 1)
[17:29:24.986] resolve() on list ... DONE
[17:29:24.987] resolve() on list ...
[17:29:24.987]  recursive: 0
[17:29:24.988]  length: 1
[17:29:24.988] 
[17:29:24.988]  length: 0 (resolved future 1)
[17:29:24.988] resolve() on list ... DONE
[17:29:24.989] resolve() on list ...
[17:29:24.989]  recursive: 0
[17:29:24.989]  length: 4
[17:29:24.990] 
[17:29:24.990] Future #1
[17:29:24.990]  length: 3 (resolved future 1)
[17:29:24.991] Future #2
[17:29:24.991]  length: 2 (resolved future 2)
[17:29:24.991]  length: 1 (resolved future 3)
[17:29:24.991]  length: 0 (resolved future 4)
[17:29:24.992] resolve() on list ... DONE
[17:29:24.992] resolve() on list ...
[17:29:24.992]  recursive: 0
[17:29:24.993]  length: 4
[17:29:24.993] 
[17:29:24.993] Future #1
[17:29:24.994]  length: 3 (resolved future 1)
[17:29:24.994] Future #2
[17:29:24.994]  length: 2 (resolved future 2)
[17:29:24.995]  length: 1 (resolved future 3)
[17:29:24.995]  length: 0 (resolved future 4)
[17:29:24.995] resolve() on list ... DONE
[17:29:24.996] resolve() on list ...
[17:29:24.996]  recursive: 0
[17:29:24.996]  length: 1
[17:29:24.996] 
[17:29:24.997]  length: 0 (resolved future 1)
[17:29:24.997] resolve() on list ... DONE
[17:29:24.997] getGlobalsAndPackages() ...
[17:29:24.998] Searching for globals...
[17:29:25.000] - globals found: [3] '{', 'Sys.sleep', 'kk'
[17:29:25.000] Searching for globals ... DONE
[17:29:25.000] Resolving globals: FALSE
[17:29:25.001] The total size of the 1 globals is 35 bytes (35 bytes)
[17:29:25.002] The total size of the 1 globals exported for future expression ('{; Sys.sleep(0.1); kk; }') is 35 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'kk' (35 bytes of class 'numeric')
[17:29:25.002] - globals: [1] 'kk'
[17:29:25.003] 
[17:29:25.003] getGlobalsAndPackages() ... DONE
[17:29:25.003] run() for 'Future' ...
[17:29:25.004] - state: 'created'
[17:29:25.004] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:25.023] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:25.023] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:25.024]   - Field: 'node'
[17:29:25.024]   - Field: 'label'
[17:29:25.024]   - Field: 'local'
[17:29:25.025]   - Field: 'owner'
[17:29:25.025]   - Field: 'envir'
[17:29:25.025]   - Field: 'workers'
[17:29:25.026]   - Field: 'packages'
[17:29:25.026]   - Field: 'gc'
[17:29:25.026]   - Field: 'conditions'
[17:29:25.027]   - Field: 'persistent'
[17:29:25.027]   - Field: 'expr'
[17:29:25.027]   - Field: 'uuid'
[17:29:25.027]   - Field: 'seed'
[17:29:25.028]   - Field: 'version'
[17:29:25.028]   - Field: 'result'
[17:29:25.028]   - Field: 'asynchronous'
[17:29:25.029]   - Field: 'calls'
[17:29:25.029]   - Field: 'globals'
[17:29:25.029]   - Field: 'stdout'
[17:29:25.030]   - Field: 'earlySignal'
[17:29:25.030]   - Field: 'lazy'
[17:29:25.030]   - Field: 'state'
[17:29:25.031] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:25.031] - Launch lazy future ...
[17:29:25.032] Packages needed by the future expression (n = 0): <none>
[17:29:25.032] Packages needed by future strategies (n = 0): <none>
[17:29:25.033] {
[17:29:25.033]     {
[17:29:25.033]         {
[17:29:25.033]             ...future.startTime <- base::Sys.time()
[17:29:25.033]             {
[17:29:25.033]                 {
[17:29:25.033]                   {
[17:29:25.033]                     {
[17:29:25.033]                       base::local({
[17:29:25.033]                         has_future <- base::requireNamespace("future", 
[17:29:25.033]                           quietly = TRUE)
[17:29:25.033]                         if (has_future) {
[17:29:25.033]                           ns <- base::getNamespace("future")
[17:29:25.033]                           version <- ns[[".package"]][["version"]]
[17:29:25.033]                           if (is.null(version)) 
[17:29:25.033]                             version <- utils::packageVersion("future")
[17:29:25.033]                         }
[17:29:25.033]                         else {
[17:29:25.033]                           version <- NULL
[17:29:25.033]                         }
[17:29:25.033]                         if (!has_future || version < "1.8.0") {
[17:29:25.033]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:25.033]                             "", base::R.version$version.string), 
[17:29:25.033]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:25.033]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:25.033]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:25.033]                               "release", "version")], collapse = " "), 
[17:29:25.033]                             hostname = base::Sys.info()[["nodename"]])
[17:29:25.033]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:25.033]                             info)
[17:29:25.033]                           info <- base::paste(info, collapse = "; ")
[17:29:25.033]                           if (!has_future) {
[17:29:25.033]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:25.033]                               info)
[17:29:25.033]                           }
[17:29:25.033]                           else {
[17:29:25.033]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:25.033]                               info, version)
[17:29:25.033]                           }
[17:29:25.033]                           base::stop(msg)
[17:29:25.033]                         }
[17:29:25.033]                       })
[17:29:25.033]                     }
[17:29:25.033]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:25.033]                     base::options(mc.cores = 1L)
[17:29:25.033]                   }
[17:29:25.033]                   ...future.strategy.old <- future::plan("list")
[17:29:25.033]                   options(future.plan = NULL)
[17:29:25.033]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:25.033]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:25.033]                 }
[17:29:25.033]                 ...future.workdir <- getwd()
[17:29:25.033]             }
[17:29:25.033]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:25.033]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:25.033]         }
[17:29:25.033]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:25.033]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:25.033]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:25.033]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:25.033]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:25.033]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:25.033]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:25.033]             base::names(...future.oldOptions))
[17:29:25.033]     }
[17:29:25.033]     if (FALSE) {
[17:29:25.033]     }
[17:29:25.033]     else {
[17:29:25.033]         if (TRUE) {
[17:29:25.033]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:25.033]                 open = "w")
[17:29:25.033]         }
[17:29:25.033]         else {
[17:29:25.033]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:25.033]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:25.033]         }
[17:29:25.033]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:25.033]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:25.033]             base::sink(type = "output", split = FALSE)
[17:29:25.033]             base::close(...future.stdout)
[17:29:25.033]         }, add = TRUE)
[17:29:25.033]     }
[17:29:25.033]     ...future.frame <- base::sys.nframe()
[17:29:25.033]     ...future.conditions <- base::list()
[17:29:25.033]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:25.033]     if (FALSE) {
[17:29:25.033]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:25.033]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:25.033]     }
[17:29:25.033]     ...future.result <- base::tryCatch({
[17:29:25.033]         base::withCallingHandlers({
[17:29:25.033]             ...future.value <- base::withVisible(base::local({
[17:29:25.033]                 ...future.makeSendCondition <- base::local({
[17:29:25.033]                   sendCondition <- NULL
[17:29:25.033]                   function(frame = 1L) {
[17:29:25.033]                     if (is.function(sendCondition)) 
[17:29:25.033]                       return(sendCondition)
[17:29:25.033]                     ns <- getNamespace("parallel")
[17:29:25.033]                     if (exists("sendData", mode = "function", 
[17:29:25.033]                       envir = ns)) {
[17:29:25.033]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:25.033]                         envir = ns)
[17:29:25.033]                       envir <- sys.frame(frame)
[17:29:25.033]                       master <- NULL
[17:29:25.033]                       while (!identical(envir, .GlobalEnv) && 
[17:29:25.033]                         !identical(envir, emptyenv())) {
[17:29:25.033]                         if (exists("master", mode = "list", envir = envir, 
[17:29:25.033]                           inherits = FALSE)) {
[17:29:25.033]                           master <- get("master", mode = "list", 
[17:29:25.033]                             envir = envir, inherits = FALSE)
[17:29:25.033]                           if (inherits(master, c("SOCKnode", 
[17:29:25.033]                             "SOCK0node"))) {
[17:29:25.033]                             sendCondition <<- function(cond) {
[17:29:25.033]                               data <- list(type = "VALUE", value = cond, 
[17:29:25.033]                                 success = TRUE)
[17:29:25.033]                               parallel_sendData(master, data)
[17:29:25.033]                             }
[17:29:25.033]                             return(sendCondition)
[17:29:25.033]                           }
[17:29:25.033]                         }
[17:29:25.033]                         frame <- frame + 1L
[17:29:25.033]                         envir <- sys.frame(frame)
[17:29:25.033]                       }
[17:29:25.033]                     }
[17:29:25.033]                     sendCondition <<- function(cond) NULL
[17:29:25.033]                   }
[17:29:25.033]                 })
[17:29:25.033]                 withCallingHandlers({
[17:29:25.033]                   {
[17:29:25.033]                     Sys.sleep(0.1)
[17:29:25.033]                     kk
[17:29:25.033]                   }
[17:29:25.033]                 }, immediateCondition = function(cond) {
[17:29:25.033]                   sendCondition <- ...future.makeSendCondition()
[17:29:25.033]                   sendCondition(cond)
[17:29:25.033]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:25.033]                   {
[17:29:25.033]                     inherits <- base::inherits
[17:29:25.033]                     invokeRestart <- base::invokeRestart
[17:29:25.033]                     is.null <- base::is.null
[17:29:25.033]                     muffled <- FALSE
[17:29:25.033]                     if (inherits(cond, "message")) {
[17:29:25.033]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:25.033]                       if (muffled) 
[17:29:25.033]                         invokeRestart("muffleMessage")
[17:29:25.033]                     }
[17:29:25.033]                     else if (inherits(cond, "warning")) {
[17:29:25.033]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:25.033]                       if (muffled) 
[17:29:25.033]                         invokeRestart("muffleWarning")
[17:29:25.033]                     }
[17:29:25.033]                     else if (inherits(cond, "condition")) {
[17:29:25.033]                       if (!is.null(pattern)) {
[17:29:25.033]                         computeRestarts <- base::computeRestarts
[17:29:25.033]                         grepl <- base::grepl
[17:29:25.033]                         restarts <- computeRestarts(cond)
[17:29:25.033]                         for (restart in restarts) {
[17:29:25.033]                           name <- restart$name
[17:29:25.033]                           if (is.null(name)) 
[17:29:25.033]                             next
[17:29:25.033]                           if (!grepl(pattern, name)) 
[17:29:25.033]                             next
[17:29:25.033]                           invokeRestart(restart)
[17:29:25.033]                           muffled <- TRUE
[17:29:25.033]                           break
[17:29:25.033]                         }
[17:29:25.033]                       }
[17:29:25.033]                     }
[17:29:25.033]                     invisible(muffled)
[17:29:25.033]                   }
[17:29:25.033]                   muffleCondition(cond)
[17:29:25.033]                 })
[17:29:25.033]             }))
[17:29:25.033]             future::FutureResult(value = ...future.value$value, 
[17:29:25.033]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:25.033]                   ...future.rng), globalenv = if (FALSE) 
[17:29:25.033]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:25.033]                     ...future.globalenv.names))
[17:29:25.033]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:25.033]         }, condition = base::local({
[17:29:25.033]             c <- base::c
[17:29:25.033]             inherits <- base::inherits
[17:29:25.033]             invokeRestart <- base::invokeRestart
[17:29:25.033]             length <- base::length
[17:29:25.033]             list <- base::list
[17:29:25.033]             seq.int <- base::seq.int
[17:29:25.033]             signalCondition <- base::signalCondition
[17:29:25.033]             sys.calls <- base::sys.calls
[17:29:25.033]             `[[` <- base::`[[`
[17:29:25.033]             `+` <- base::`+`
[17:29:25.033]             `<<-` <- base::`<<-`
[17:29:25.033]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:25.033]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:25.033]                   3L)]
[17:29:25.033]             }
[17:29:25.033]             function(cond) {
[17:29:25.033]                 is_error <- inherits(cond, "error")
[17:29:25.033]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:25.033]                   NULL)
[17:29:25.033]                 if (is_error) {
[17:29:25.033]                   sessionInformation <- function() {
[17:29:25.033]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:25.033]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:25.033]                       search = base::search(), system = base::Sys.info())
[17:29:25.033]                   }
[17:29:25.033]                   ...future.conditions[[length(...future.conditions) + 
[17:29:25.033]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:25.033]                     cond$call), session = sessionInformation(), 
[17:29:25.033]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:25.033]                   signalCondition(cond)
[17:29:25.033]                 }
[17:29:25.033]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:25.033]                 "immediateCondition"))) {
[17:29:25.033]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:25.033]                   ...future.conditions[[length(...future.conditions) + 
[17:29:25.033]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:25.033]                   if (TRUE && !signal) {
[17:29:25.033]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:25.033]                     {
[17:29:25.033]                       inherits <- base::inherits
[17:29:25.033]                       invokeRestart <- base::invokeRestart
[17:29:25.033]                       is.null <- base::is.null
[17:29:25.033]                       muffled <- FALSE
[17:29:25.033]                       if (inherits(cond, "message")) {
[17:29:25.033]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:25.033]                         if (muffled) 
[17:29:25.033]                           invokeRestart("muffleMessage")
[17:29:25.033]                       }
[17:29:25.033]                       else if (inherits(cond, "warning")) {
[17:29:25.033]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:25.033]                         if (muffled) 
[17:29:25.033]                           invokeRestart("muffleWarning")
[17:29:25.033]                       }
[17:29:25.033]                       else if (inherits(cond, "condition")) {
[17:29:25.033]                         if (!is.null(pattern)) {
[17:29:25.033]                           computeRestarts <- base::computeRestarts
[17:29:25.033]                           grepl <- base::grepl
[17:29:25.033]                           restarts <- computeRestarts(cond)
[17:29:25.033]                           for (restart in restarts) {
[17:29:25.033]                             name <- restart$name
[17:29:25.033]                             if (is.null(name)) 
[17:29:25.033]                               next
[17:29:25.033]                             if (!grepl(pattern, name)) 
[17:29:25.033]                               next
[17:29:25.033]                             invokeRestart(restart)
[17:29:25.033]                             muffled <- TRUE
[17:29:25.033]                             break
[17:29:25.033]                           }
[17:29:25.033]                         }
[17:29:25.033]                       }
[17:29:25.033]                       invisible(muffled)
[17:29:25.033]                     }
[17:29:25.033]                     muffleCondition(cond, pattern = "^muffle")
[17:29:25.033]                   }
[17:29:25.033]                 }
[17:29:25.033]                 else {
[17:29:25.033]                   if (TRUE) {
[17:29:25.033]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:25.033]                     {
[17:29:25.033]                       inherits <- base::inherits
[17:29:25.033]                       invokeRestart <- base::invokeRestart
[17:29:25.033]                       is.null <- base::is.null
[17:29:25.033]                       muffled <- FALSE
[17:29:25.033]                       if (inherits(cond, "message")) {
[17:29:25.033]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:25.033]                         if (muffled) 
[17:29:25.033]                           invokeRestart("muffleMessage")
[17:29:25.033]                       }
[17:29:25.033]                       else if (inherits(cond, "warning")) {
[17:29:25.033]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:25.033]                         if (muffled) 
[17:29:25.033]                           invokeRestart("muffleWarning")
[17:29:25.033]                       }
[17:29:25.033]                       else if (inherits(cond, "condition")) {
[17:29:25.033]                         if (!is.null(pattern)) {
[17:29:25.033]                           computeRestarts <- base::computeRestarts
[17:29:25.033]                           grepl <- base::grepl
[17:29:25.033]                           restarts <- computeRestarts(cond)
[17:29:25.033]                           for (restart in restarts) {
[17:29:25.033]                             name <- restart$name
[17:29:25.033]                             if (is.null(name)) 
[17:29:25.033]                               next
[17:29:25.033]                             if (!grepl(pattern, name)) 
[17:29:25.033]                               next
[17:29:25.033]                             invokeRestart(restart)
[17:29:25.033]                             muffled <- TRUE
[17:29:25.033]                             break
[17:29:25.033]                           }
[17:29:25.033]                         }
[17:29:25.033]                       }
[17:29:25.033]                       invisible(muffled)
[17:29:25.033]                     }
[17:29:25.033]                     muffleCondition(cond, pattern = "^muffle")
[17:29:25.033]                   }
[17:29:25.033]                 }
[17:29:25.033]             }
[17:29:25.033]         }))
[17:29:25.033]     }, error = function(ex) {
[17:29:25.033]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:25.033]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:25.033]                 ...future.rng), started = ...future.startTime, 
[17:29:25.033]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:25.033]             version = "1.8"), class = "FutureResult")
[17:29:25.033]     }, finally = {
[17:29:25.033]         if (!identical(...future.workdir, getwd())) 
[17:29:25.033]             setwd(...future.workdir)
[17:29:25.033]         {
[17:29:25.033]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:25.033]                 ...future.oldOptions$nwarnings <- NULL
[17:29:25.033]             }
[17:29:25.033]             base::options(...future.oldOptions)
[17:29:25.033]             if (.Platform$OS.type == "windows") {
[17:29:25.033]                 old_names <- names(...future.oldEnvVars)
[17:29:25.033]                 envs <- base::Sys.getenv()
[17:29:25.033]                 names <- names(envs)
[17:29:25.033]                 common <- intersect(names, old_names)
[17:29:25.033]                 added <- setdiff(names, old_names)
[17:29:25.033]                 removed <- setdiff(old_names, names)
[17:29:25.033]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:25.033]                   envs[common]]
[17:29:25.033]                 NAMES <- toupper(changed)
[17:29:25.033]                 args <- list()
[17:29:25.033]                 for (kk in seq_along(NAMES)) {
[17:29:25.033]                   name <- changed[[kk]]
[17:29:25.033]                   NAME <- NAMES[[kk]]
[17:29:25.033]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:25.033]                     next
[17:29:25.033]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:25.033]                 }
[17:29:25.033]                 NAMES <- toupper(added)
[17:29:25.033]                 for (kk in seq_along(NAMES)) {
[17:29:25.033]                   name <- added[[kk]]
[17:29:25.033]                   NAME <- NAMES[[kk]]
[17:29:25.033]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:25.033]                     next
[17:29:25.033]                   args[[name]] <- ""
[17:29:25.033]                 }
[17:29:25.033]                 NAMES <- toupper(removed)
[17:29:25.033]                 for (kk in seq_along(NAMES)) {
[17:29:25.033]                   name <- removed[[kk]]
[17:29:25.033]                   NAME <- NAMES[[kk]]
[17:29:25.033]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:25.033]                     next
[17:29:25.033]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:25.033]                 }
[17:29:25.033]                 if (length(args) > 0) 
[17:29:25.033]                   base::do.call(base::Sys.setenv, args = args)
[17:29:25.033]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:25.033]             }
[17:29:25.033]             else {
[17:29:25.033]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:25.033]             }
[17:29:25.033]             {
[17:29:25.033]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:25.033]                   0L) {
[17:29:25.033]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:25.033]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:25.033]                   base::options(opts)
[17:29:25.033]                 }
[17:29:25.033]                 {
[17:29:25.033]                   {
[17:29:25.033]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:25.033]                     NULL
[17:29:25.033]                   }
[17:29:25.033]                   options(future.plan = NULL)
[17:29:25.033]                   if (is.na(NA_character_)) 
[17:29:25.033]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:25.033]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:25.033]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:25.033]                     .init = FALSE)
[17:29:25.033]                 }
[17:29:25.033]             }
[17:29:25.033]         }
[17:29:25.033]     })
[17:29:25.033]     if (TRUE) {
[17:29:25.033]         base::sink(type = "output", split = FALSE)
[17:29:25.033]         if (TRUE) {
[17:29:25.033]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:25.033]         }
[17:29:25.033]         else {
[17:29:25.033]             ...future.result["stdout"] <- base::list(NULL)
[17:29:25.033]         }
[17:29:25.033]         base::close(...future.stdout)
[17:29:25.033]         ...future.stdout <- NULL
[17:29:25.033]     }
[17:29:25.033]     ...future.result$conditions <- ...future.conditions
[17:29:25.033]     ...future.result$finished <- base::Sys.time()
[17:29:25.033]     ...future.result
[17:29:25.033] }
[17:29:25.042] Exporting 1 global objects (340 bytes) to cluster node #1 ...
[17:29:25.042] Exporting 'kk' (35 bytes) to cluster node #1 ...
[17:29:25.043] Exporting 'kk' (35 bytes) to cluster node #1 ... DONE
[17:29:25.043] Exporting 1 global objects (340 bytes) to cluster node #1 ... DONE
[17:29:25.044] MultisessionFuture started
[17:29:25.044] - Launch lazy future ... done
[17:29:25.044] run() for 'MultisessionFuture' ... done
[17:29:25.045] getGlobalsAndPackages() ...
[17:29:25.045] Searching for globals...
[17:29:25.047] - globals found: [3] '{', 'Sys.sleep', 'kk'
[17:29:25.047] Searching for globals ... DONE
[17:29:25.048] Resolving globals: FALSE
[17:29:25.048] The total size of the 1 globals is 35 bytes (35 bytes)
[17:29:25.049] The total size of the 1 globals exported for future expression ('{; Sys.sleep(0.1); kk; }') is 35 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'kk' (35 bytes of class 'numeric')
[17:29:25.049] - globals: [1] 'kk'
[17:29:25.050] 
[17:29:25.050] getGlobalsAndPackages() ... DONE
[17:29:25.050] run() for 'Future' ...
[17:29:25.051] - state: 'created'
[17:29:25.051] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:25.067] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:25.068] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:25.068]   - Field: 'node'
[17:29:25.068]   - Field: 'label'
[17:29:25.068]   - Field: 'local'
[17:29:25.068]   - Field: 'owner'
[17:29:25.069]   - Field: 'envir'
[17:29:25.069]   - Field: 'workers'
[17:29:25.069]   - Field: 'packages'
[17:29:25.069]   - Field: 'gc'
[17:29:25.069]   - Field: 'conditions'
[17:29:25.069]   - Field: 'persistent'
[17:29:25.070]   - Field: 'expr'
[17:29:25.070]   - Field: 'uuid'
[17:29:25.070]   - Field: 'seed'
[17:29:25.070]   - Field: 'version'
[17:29:25.070]   - Field: 'result'
[17:29:25.071]   - Field: 'asynchronous'
[17:29:25.071]   - Field: 'calls'
[17:29:25.071]   - Field: 'globals'
[17:29:25.071]   - Field: 'stdout'
[17:29:25.071]   - Field: 'earlySignal'
[17:29:25.072]   - Field: 'lazy'
[17:29:25.072]   - Field: 'state'
[17:29:25.072] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:25.072] - Launch lazy future ...
[17:29:25.073] Packages needed by the future expression (n = 0): <none>
[17:29:25.073] Packages needed by future strategies (n = 0): <none>
[17:29:25.073] {
[17:29:25.073]     {
[17:29:25.073]         {
[17:29:25.073]             ...future.startTime <- base::Sys.time()
[17:29:25.073]             {
[17:29:25.073]                 {
[17:29:25.073]                   {
[17:29:25.073]                     {
[17:29:25.073]                       base::local({
[17:29:25.073]                         has_future <- base::requireNamespace("future", 
[17:29:25.073]                           quietly = TRUE)
[17:29:25.073]                         if (has_future) {
[17:29:25.073]                           ns <- base::getNamespace("future")
[17:29:25.073]                           version <- ns[[".package"]][["version"]]
[17:29:25.073]                           if (is.null(version)) 
[17:29:25.073]                             version <- utils::packageVersion("future")
[17:29:25.073]                         }
[17:29:25.073]                         else {
[17:29:25.073]                           version <- NULL
[17:29:25.073]                         }
[17:29:25.073]                         if (!has_future || version < "1.8.0") {
[17:29:25.073]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:25.073]                             "", base::R.version$version.string), 
[17:29:25.073]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:25.073]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:25.073]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:25.073]                               "release", "version")], collapse = " "), 
[17:29:25.073]                             hostname = base::Sys.info()[["nodename"]])
[17:29:25.073]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:25.073]                             info)
[17:29:25.073]                           info <- base::paste(info, collapse = "; ")
[17:29:25.073]                           if (!has_future) {
[17:29:25.073]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:25.073]                               info)
[17:29:25.073]                           }
[17:29:25.073]                           else {
[17:29:25.073]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:25.073]                               info, version)
[17:29:25.073]                           }
[17:29:25.073]                           base::stop(msg)
[17:29:25.073]                         }
[17:29:25.073]                       })
[17:29:25.073]                     }
[17:29:25.073]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:25.073]                     base::options(mc.cores = 1L)
[17:29:25.073]                   }
[17:29:25.073]                   ...future.strategy.old <- future::plan("list")
[17:29:25.073]                   options(future.plan = NULL)
[17:29:25.073]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:25.073]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:25.073]                 }
[17:29:25.073]                 ...future.workdir <- getwd()
[17:29:25.073]             }
[17:29:25.073]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:25.073]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:25.073]         }
[17:29:25.073]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:25.073]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:25.073]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:25.073]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:25.073]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:25.073]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:25.073]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:25.073]             base::names(...future.oldOptions))
[17:29:25.073]     }
[17:29:25.073]     if (FALSE) {
[17:29:25.073]     }
[17:29:25.073]     else {
[17:29:25.073]         if (TRUE) {
[17:29:25.073]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:25.073]                 open = "w")
[17:29:25.073]         }
[17:29:25.073]         else {
[17:29:25.073]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:25.073]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:25.073]         }
[17:29:25.073]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:25.073]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:25.073]             base::sink(type = "output", split = FALSE)
[17:29:25.073]             base::close(...future.stdout)
[17:29:25.073]         }, add = TRUE)
[17:29:25.073]     }
[17:29:25.073]     ...future.frame <- base::sys.nframe()
[17:29:25.073]     ...future.conditions <- base::list()
[17:29:25.073]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:25.073]     if (FALSE) {
[17:29:25.073]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:25.073]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:25.073]     }
[17:29:25.073]     ...future.result <- base::tryCatch({
[17:29:25.073]         base::withCallingHandlers({
[17:29:25.073]             ...future.value <- base::withVisible(base::local({
[17:29:25.073]                 ...future.makeSendCondition <- base::local({
[17:29:25.073]                   sendCondition <- NULL
[17:29:25.073]                   function(frame = 1L) {
[17:29:25.073]                     if (is.function(sendCondition)) 
[17:29:25.073]                       return(sendCondition)
[17:29:25.073]                     ns <- getNamespace("parallel")
[17:29:25.073]                     if (exists("sendData", mode = "function", 
[17:29:25.073]                       envir = ns)) {
[17:29:25.073]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:25.073]                         envir = ns)
[17:29:25.073]                       envir <- sys.frame(frame)
[17:29:25.073]                       master <- NULL
[17:29:25.073]                       while (!identical(envir, .GlobalEnv) && 
[17:29:25.073]                         !identical(envir, emptyenv())) {
[17:29:25.073]                         if (exists("master", mode = "list", envir = envir, 
[17:29:25.073]                           inherits = FALSE)) {
[17:29:25.073]                           master <- get("master", mode = "list", 
[17:29:25.073]                             envir = envir, inherits = FALSE)
[17:29:25.073]                           if (inherits(master, c("SOCKnode", 
[17:29:25.073]                             "SOCK0node"))) {
[17:29:25.073]                             sendCondition <<- function(cond) {
[17:29:25.073]                               data <- list(type = "VALUE", value = cond, 
[17:29:25.073]                                 success = TRUE)
[17:29:25.073]                               parallel_sendData(master, data)
[17:29:25.073]                             }
[17:29:25.073]                             return(sendCondition)
[17:29:25.073]                           }
[17:29:25.073]                         }
[17:29:25.073]                         frame <- frame + 1L
[17:29:25.073]                         envir <- sys.frame(frame)
[17:29:25.073]                       }
[17:29:25.073]                     }
[17:29:25.073]                     sendCondition <<- function(cond) NULL
[17:29:25.073]                   }
[17:29:25.073]                 })
[17:29:25.073]                 withCallingHandlers({
[17:29:25.073]                   {
[17:29:25.073]                     Sys.sleep(0.1)
[17:29:25.073]                     kk
[17:29:25.073]                   }
[17:29:25.073]                 }, immediateCondition = function(cond) {
[17:29:25.073]                   sendCondition <- ...future.makeSendCondition()
[17:29:25.073]                   sendCondition(cond)
[17:29:25.073]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:25.073]                   {
[17:29:25.073]                     inherits <- base::inherits
[17:29:25.073]                     invokeRestart <- base::invokeRestart
[17:29:25.073]                     is.null <- base::is.null
[17:29:25.073]                     muffled <- FALSE
[17:29:25.073]                     if (inherits(cond, "message")) {
[17:29:25.073]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:25.073]                       if (muffled) 
[17:29:25.073]                         invokeRestart("muffleMessage")
[17:29:25.073]                     }
[17:29:25.073]                     else if (inherits(cond, "warning")) {
[17:29:25.073]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:25.073]                       if (muffled) 
[17:29:25.073]                         invokeRestart("muffleWarning")
[17:29:25.073]                     }
[17:29:25.073]                     else if (inherits(cond, "condition")) {
[17:29:25.073]                       if (!is.null(pattern)) {
[17:29:25.073]                         computeRestarts <- base::computeRestarts
[17:29:25.073]                         grepl <- base::grepl
[17:29:25.073]                         restarts <- computeRestarts(cond)
[17:29:25.073]                         for (restart in restarts) {
[17:29:25.073]                           name <- restart$name
[17:29:25.073]                           if (is.null(name)) 
[17:29:25.073]                             next
[17:29:25.073]                           if (!grepl(pattern, name)) 
[17:29:25.073]                             next
[17:29:25.073]                           invokeRestart(restart)
[17:29:25.073]                           muffled <- TRUE
[17:29:25.073]                           break
[17:29:25.073]                         }
[17:29:25.073]                       }
[17:29:25.073]                     }
[17:29:25.073]                     invisible(muffled)
[17:29:25.073]                   }
[17:29:25.073]                   muffleCondition(cond)
[17:29:25.073]                 })
[17:29:25.073]             }))
[17:29:25.073]             future::FutureResult(value = ...future.value$value, 
[17:29:25.073]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:25.073]                   ...future.rng), globalenv = if (FALSE) 
[17:29:25.073]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:25.073]                     ...future.globalenv.names))
[17:29:25.073]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:25.073]         }, condition = base::local({
[17:29:25.073]             c <- base::c
[17:29:25.073]             inherits <- base::inherits
[17:29:25.073]             invokeRestart <- base::invokeRestart
[17:29:25.073]             length <- base::length
[17:29:25.073]             list <- base::list
[17:29:25.073]             seq.int <- base::seq.int
[17:29:25.073]             signalCondition <- base::signalCondition
[17:29:25.073]             sys.calls <- base::sys.calls
[17:29:25.073]             `[[` <- base::`[[`
[17:29:25.073]             `+` <- base::`+`
[17:29:25.073]             `<<-` <- base::`<<-`
[17:29:25.073]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:25.073]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:25.073]                   3L)]
[17:29:25.073]             }
[17:29:25.073]             function(cond) {
[17:29:25.073]                 is_error <- inherits(cond, "error")
[17:29:25.073]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:25.073]                   NULL)
[17:29:25.073]                 if (is_error) {
[17:29:25.073]                   sessionInformation <- function() {
[17:29:25.073]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:25.073]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:25.073]                       search = base::search(), system = base::Sys.info())
[17:29:25.073]                   }
[17:29:25.073]                   ...future.conditions[[length(...future.conditions) + 
[17:29:25.073]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:25.073]                     cond$call), session = sessionInformation(), 
[17:29:25.073]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:25.073]                   signalCondition(cond)
[17:29:25.073]                 }
[17:29:25.073]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:25.073]                 "immediateCondition"))) {
[17:29:25.073]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:25.073]                   ...future.conditions[[length(...future.conditions) + 
[17:29:25.073]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:25.073]                   if (TRUE && !signal) {
[17:29:25.073]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:25.073]                     {
[17:29:25.073]                       inherits <- base::inherits
[17:29:25.073]                       invokeRestart <- base::invokeRestart
[17:29:25.073]                       is.null <- base::is.null
[17:29:25.073]                       muffled <- FALSE
[17:29:25.073]                       if (inherits(cond, "message")) {
[17:29:25.073]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:25.073]                         if (muffled) 
[17:29:25.073]                           invokeRestart("muffleMessage")
[17:29:25.073]                       }
[17:29:25.073]                       else if (inherits(cond, "warning")) {
[17:29:25.073]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:25.073]                         if (muffled) 
[17:29:25.073]                           invokeRestart("muffleWarning")
[17:29:25.073]                       }
[17:29:25.073]                       else if (inherits(cond, "condition")) {
[17:29:25.073]                         if (!is.null(pattern)) {
[17:29:25.073]                           computeRestarts <- base::computeRestarts
[17:29:25.073]                           grepl <- base::grepl
[17:29:25.073]                           restarts <- computeRestarts(cond)
[17:29:25.073]                           for (restart in restarts) {
[17:29:25.073]                             name <- restart$name
[17:29:25.073]                             if (is.null(name)) 
[17:29:25.073]                               next
[17:29:25.073]                             if (!grepl(pattern, name)) 
[17:29:25.073]                               next
[17:29:25.073]                             invokeRestart(restart)
[17:29:25.073]                             muffled <- TRUE
[17:29:25.073]                             break
[17:29:25.073]                           }
[17:29:25.073]                         }
[17:29:25.073]                       }
[17:29:25.073]                       invisible(muffled)
[17:29:25.073]                     }
[17:29:25.073]                     muffleCondition(cond, pattern = "^muffle")
[17:29:25.073]                   }
[17:29:25.073]                 }
[17:29:25.073]                 else {
[17:29:25.073]                   if (TRUE) {
[17:29:25.073]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:25.073]                     {
[17:29:25.073]                       inherits <- base::inherits
[17:29:25.073]                       invokeRestart <- base::invokeRestart
[17:29:25.073]                       is.null <- base::is.null
[17:29:25.073]                       muffled <- FALSE
[17:29:25.073]                       if (inherits(cond, "message")) {
[17:29:25.073]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:25.073]                         if (muffled) 
[17:29:25.073]                           invokeRestart("muffleMessage")
[17:29:25.073]                       }
[17:29:25.073]                       else if (inherits(cond, "warning")) {
[17:29:25.073]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:25.073]                         if (muffled) 
[17:29:25.073]                           invokeRestart("muffleWarning")
[17:29:25.073]                       }
[17:29:25.073]                       else if (inherits(cond, "condition")) {
[17:29:25.073]                         if (!is.null(pattern)) {
[17:29:25.073]                           computeRestarts <- base::computeRestarts
[17:29:25.073]                           grepl <- base::grepl
[17:29:25.073]                           restarts <- computeRestarts(cond)
[17:29:25.073]                           for (restart in restarts) {
[17:29:25.073]                             name <- restart$name
[17:29:25.073]                             if (is.null(name)) 
[17:29:25.073]                               next
[17:29:25.073]                             if (!grepl(pattern, name)) 
[17:29:25.073]                               next
[17:29:25.073]                             invokeRestart(restart)
[17:29:25.073]                             muffled <- TRUE
[17:29:25.073]                             break
[17:29:25.073]                           }
[17:29:25.073]                         }
[17:29:25.073]                       }
[17:29:25.073]                       invisible(muffled)
[17:29:25.073]                     }
[17:29:25.073]                     muffleCondition(cond, pattern = "^muffle")
[17:29:25.073]                   }
[17:29:25.073]                 }
[17:29:25.073]             }
[17:29:25.073]         }))
[17:29:25.073]     }, error = function(ex) {
[17:29:25.073]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:25.073]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:25.073]                 ...future.rng), started = ...future.startTime, 
[17:29:25.073]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:25.073]             version = "1.8"), class = "FutureResult")
[17:29:25.073]     }, finally = {
[17:29:25.073]         if (!identical(...future.workdir, getwd())) 
[17:29:25.073]             setwd(...future.workdir)
[17:29:25.073]         {
[17:29:25.073]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:25.073]                 ...future.oldOptions$nwarnings <- NULL
[17:29:25.073]             }
[17:29:25.073]             base::options(...future.oldOptions)
[17:29:25.073]             if (.Platform$OS.type == "windows") {
[17:29:25.073]                 old_names <- names(...future.oldEnvVars)
[17:29:25.073]                 envs <- base::Sys.getenv()
[17:29:25.073]                 names <- names(envs)
[17:29:25.073]                 common <- intersect(names, old_names)
[17:29:25.073]                 added <- setdiff(names, old_names)
[17:29:25.073]                 removed <- setdiff(old_names, names)
[17:29:25.073]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:25.073]                   envs[common]]
[17:29:25.073]                 NAMES <- toupper(changed)
[17:29:25.073]                 args <- list()
[17:29:25.073]                 for (kk in seq_along(NAMES)) {
[17:29:25.073]                   name <- changed[[kk]]
[17:29:25.073]                   NAME <- NAMES[[kk]]
[17:29:25.073]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:25.073]                     next
[17:29:25.073]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:25.073]                 }
[17:29:25.073]                 NAMES <- toupper(added)
[17:29:25.073]                 for (kk in seq_along(NAMES)) {
[17:29:25.073]                   name <- added[[kk]]
[17:29:25.073]                   NAME <- NAMES[[kk]]
[17:29:25.073]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:25.073]                     next
[17:29:25.073]                   args[[name]] <- ""
[17:29:25.073]                 }
[17:29:25.073]                 NAMES <- toupper(removed)
[17:29:25.073]                 for (kk in seq_along(NAMES)) {
[17:29:25.073]                   name <- removed[[kk]]
[17:29:25.073]                   NAME <- NAMES[[kk]]
[17:29:25.073]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:25.073]                     next
[17:29:25.073]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:25.073]                 }
[17:29:25.073]                 if (length(args) > 0) 
[17:29:25.073]                   base::do.call(base::Sys.setenv, args = args)
[17:29:25.073]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:25.073]             }
[17:29:25.073]             else {
[17:29:25.073]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:25.073]             }
[17:29:25.073]             {
[17:29:25.073]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:25.073]                   0L) {
[17:29:25.073]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:25.073]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:25.073]                   base::options(opts)
[17:29:25.073]                 }
[17:29:25.073]                 {
[17:29:25.073]                   {
[17:29:25.073]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:25.073]                     NULL
[17:29:25.073]                   }
[17:29:25.073]                   options(future.plan = NULL)
[17:29:25.073]                   if (is.na(NA_character_)) 
[17:29:25.073]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:25.073]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:25.073]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:25.073]                     .init = FALSE)
[17:29:25.073]                 }
[17:29:25.073]             }
[17:29:25.073]         }
[17:29:25.073]     })
[17:29:25.073]     if (TRUE) {
[17:29:25.073]         base::sink(type = "output", split = FALSE)
[17:29:25.073]         if (TRUE) {
[17:29:25.073]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:25.073]         }
[17:29:25.073]         else {
[17:29:25.073]             ...future.result["stdout"] <- base::list(NULL)
[17:29:25.073]         }
[17:29:25.073]         base::close(...future.stdout)
[17:29:25.073]         ...future.stdout <- NULL
[17:29:25.073]     }
[17:29:25.073]     ...future.result$conditions <- ...future.conditions
[17:29:25.073]     ...future.result$finished <- base::Sys.time()
[17:29:25.073]     ...future.result
[17:29:25.073] }
[17:29:25.079] Exporting 1 global objects (340 bytes) to cluster node #2 ...
[17:29:25.079] Exporting 'kk' (35 bytes) to cluster node #2 ...
[17:29:25.080] Exporting 'kk' (35 bytes) to cluster node #2 ... DONE
[17:29:25.080] Exporting 1 global objects (340 bytes) to cluster node #2 ... DONE
[17:29:25.080] MultisessionFuture started
[17:29:25.081] - Launch lazy future ... done
[17:29:25.081] run() for 'MultisessionFuture' ... done
[17:29:25.081] getGlobalsAndPackages() ...
[17:29:25.082] Searching for globals...
[17:29:25.083] - globals found: [3] '{', 'Sys.sleep', 'kk'
[17:29:25.083] Searching for globals ... DONE
[17:29:25.084] Resolving globals: FALSE
[17:29:25.084] The total size of the 1 globals is 35 bytes (35 bytes)
[17:29:25.085] The total size of the 1 globals exported for future expression ('{; Sys.sleep(0.1); kk; }') is 35 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'kk' (35 bytes of class 'numeric')
[17:29:25.085] - globals: [1] 'kk'
[17:29:25.086] 
[17:29:25.086] getGlobalsAndPackages() ... DONE
[17:29:25.086] run() for 'Future' ...
[17:29:25.087] - state: 'created'
[17:29:25.087] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:25.105] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:25.105] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:25.106]   - Field: 'node'
[17:29:25.106]   - Field: 'label'
[17:29:25.106]   - Field: 'local'
[17:29:25.107]   - Field: 'owner'
[17:29:25.107]   - Field: 'envir'
[17:29:25.107]   - Field: 'workers'
[17:29:25.108]   - Field: 'packages'
[17:29:25.108]   - Field: 'gc'
[17:29:25.108]   - Field: 'conditions'
[17:29:25.108]   - Field: 'persistent'
[17:29:25.109]   - Field: 'expr'
[17:29:25.109]   - Field: 'uuid'
[17:29:25.109]   - Field: 'seed'
[17:29:25.110]   - Field: 'version'
[17:29:25.110]   - Field: 'result'
[17:29:25.110]   - Field: 'asynchronous'
[17:29:25.111]   - Field: 'calls'
[17:29:25.111]   - Field: 'globals'
[17:29:25.111]   - Field: 'stdout'
[17:29:25.112]   - Field: 'earlySignal'
[17:29:25.112]   - Field: 'lazy'
[17:29:25.112]   - Field: 'state'
[17:29:25.113] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:25.113] - Launch lazy future ...
[17:29:25.114] Packages needed by the future expression (n = 0): <none>
[17:29:25.114] Packages needed by future strategies (n = 0): <none>
[17:29:25.115] {
[17:29:25.115]     {
[17:29:25.115]         {
[17:29:25.115]             ...future.startTime <- base::Sys.time()
[17:29:25.115]             {
[17:29:25.115]                 {
[17:29:25.115]                   {
[17:29:25.115]                     {
[17:29:25.115]                       base::local({
[17:29:25.115]                         has_future <- base::requireNamespace("future", 
[17:29:25.115]                           quietly = TRUE)
[17:29:25.115]                         if (has_future) {
[17:29:25.115]                           ns <- base::getNamespace("future")
[17:29:25.115]                           version <- ns[[".package"]][["version"]]
[17:29:25.115]                           if (is.null(version)) 
[17:29:25.115]                             version <- utils::packageVersion("future")
[17:29:25.115]                         }
[17:29:25.115]                         else {
[17:29:25.115]                           version <- NULL
[17:29:25.115]                         }
[17:29:25.115]                         if (!has_future || version < "1.8.0") {
[17:29:25.115]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:25.115]                             "", base::R.version$version.string), 
[17:29:25.115]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:25.115]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:25.115]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:25.115]                               "release", "version")], collapse = " "), 
[17:29:25.115]                             hostname = base::Sys.info()[["nodename"]])
[17:29:25.115]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:25.115]                             info)
[17:29:25.115]                           info <- base::paste(info, collapse = "; ")
[17:29:25.115]                           if (!has_future) {
[17:29:25.115]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:25.115]                               info)
[17:29:25.115]                           }
[17:29:25.115]                           else {
[17:29:25.115]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:25.115]                               info, version)
[17:29:25.115]                           }
[17:29:25.115]                           base::stop(msg)
[17:29:25.115]                         }
[17:29:25.115]                       })
[17:29:25.115]                     }
[17:29:25.115]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:25.115]                     base::options(mc.cores = 1L)
[17:29:25.115]                   }
[17:29:25.115]                   ...future.strategy.old <- future::plan("list")
[17:29:25.115]                   options(future.plan = NULL)
[17:29:25.115]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:25.115]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:25.115]                 }
[17:29:25.115]                 ...future.workdir <- getwd()
[17:29:25.115]             }
[17:29:25.115]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:25.115]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:25.115]         }
[17:29:25.115]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:25.115]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:25.115]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:25.115]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:25.115]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:25.115]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:25.115]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:25.115]             base::names(...future.oldOptions))
[17:29:25.115]     }
[17:29:25.115]     if (FALSE) {
[17:29:25.115]     }
[17:29:25.115]     else {
[17:29:25.115]         if (TRUE) {
[17:29:25.115]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:25.115]                 open = "w")
[17:29:25.115]         }
[17:29:25.115]         else {
[17:29:25.115]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:25.115]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:25.115]         }
[17:29:25.115]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:25.115]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:25.115]             base::sink(type = "output", split = FALSE)
[17:29:25.115]             base::close(...future.stdout)
[17:29:25.115]         }, add = TRUE)
[17:29:25.115]     }
[17:29:25.115]     ...future.frame <- base::sys.nframe()
[17:29:25.115]     ...future.conditions <- base::list()
[17:29:25.115]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:25.115]     if (FALSE) {
[17:29:25.115]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:25.115]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:25.115]     }
[17:29:25.115]     ...future.result <- base::tryCatch({
[17:29:25.115]         base::withCallingHandlers({
[17:29:25.115]             ...future.value <- base::withVisible(base::local({
[17:29:25.115]                 ...future.makeSendCondition <- base::local({
[17:29:25.115]                   sendCondition <- NULL
[17:29:25.115]                   function(frame = 1L) {
[17:29:25.115]                     if (is.function(sendCondition)) 
[17:29:25.115]                       return(sendCondition)
[17:29:25.115]                     ns <- getNamespace("parallel")
[17:29:25.115]                     if (exists("sendData", mode = "function", 
[17:29:25.115]                       envir = ns)) {
[17:29:25.115]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:25.115]                         envir = ns)
[17:29:25.115]                       envir <- sys.frame(frame)
[17:29:25.115]                       master <- NULL
[17:29:25.115]                       while (!identical(envir, .GlobalEnv) && 
[17:29:25.115]                         !identical(envir, emptyenv())) {
[17:29:25.115]                         if (exists("master", mode = "list", envir = envir, 
[17:29:25.115]                           inherits = FALSE)) {
[17:29:25.115]                           master <- get("master", mode = "list", 
[17:29:25.115]                             envir = envir, inherits = FALSE)
[17:29:25.115]                           if (inherits(master, c("SOCKnode", 
[17:29:25.115]                             "SOCK0node"))) {
[17:29:25.115]                             sendCondition <<- function(cond) {
[17:29:25.115]                               data <- list(type = "VALUE", value = cond, 
[17:29:25.115]                                 success = TRUE)
[17:29:25.115]                               parallel_sendData(master, data)
[17:29:25.115]                             }
[17:29:25.115]                             return(sendCondition)
[17:29:25.115]                           }
[17:29:25.115]                         }
[17:29:25.115]                         frame <- frame + 1L
[17:29:25.115]                         envir <- sys.frame(frame)
[17:29:25.115]                       }
[17:29:25.115]                     }
[17:29:25.115]                     sendCondition <<- function(cond) NULL
[17:29:25.115]                   }
[17:29:25.115]                 })
[17:29:25.115]                 withCallingHandlers({
[17:29:25.115]                   {
[17:29:25.115]                     Sys.sleep(0.1)
[17:29:25.115]                     kk
[17:29:25.115]                   }
[17:29:25.115]                 }, immediateCondition = function(cond) {
[17:29:25.115]                   sendCondition <- ...future.makeSendCondition()
[17:29:25.115]                   sendCondition(cond)
[17:29:25.115]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:25.115]                   {
[17:29:25.115]                     inherits <- base::inherits
[17:29:25.115]                     invokeRestart <- base::invokeRestart
[17:29:25.115]                     is.null <- base::is.null
[17:29:25.115]                     muffled <- FALSE
[17:29:25.115]                     if (inherits(cond, "message")) {
[17:29:25.115]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:25.115]                       if (muffled) 
[17:29:25.115]                         invokeRestart("muffleMessage")
[17:29:25.115]                     }
[17:29:25.115]                     else if (inherits(cond, "warning")) {
[17:29:25.115]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:25.115]                       if (muffled) 
[17:29:25.115]                         invokeRestart("muffleWarning")
[17:29:25.115]                     }
[17:29:25.115]                     else if (inherits(cond, "condition")) {
[17:29:25.115]                       if (!is.null(pattern)) {
[17:29:25.115]                         computeRestarts <- base::computeRestarts
[17:29:25.115]                         grepl <- base::grepl
[17:29:25.115]                         restarts <- computeRestarts(cond)
[17:29:25.115]                         for (restart in restarts) {
[17:29:25.115]                           name <- restart$name
[17:29:25.115]                           if (is.null(name)) 
[17:29:25.115]                             next
[17:29:25.115]                           if (!grepl(pattern, name)) 
[17:29:25.115]                             next
[17:29:25.115]                           invokeRestart(restart)
[17:29:25.115]                           muffled <- TRUE
[17:29:25.115]                           break
[17:29:25.115]                         }
[17:29:25.115]                       }
[17:29:25.115]                     }
[17:29:25.115]                     invisible(muffled)
[17:29:25.115]                   }
[17:29:25.115]                   muffleCondition(cond)
[17:29:25.115]                 })
[17:29:25.115]             }))
[17:29:25.115]             future::FutureResult(value = ...future.value$value, 
[17:29:25.115]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:25.115]                   ...future.rng), globalenv = if (FALSE) 
[17:29:25.115]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:25.115]                     ...future.globalenv.names))
[17:29:25.115]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:25.115]         }, condition = base::local({
[17:29:25.115]             c <- base::c
[17:29:25.115]             inherits <- base::inherits
[17:29:25.115]             invokeRestart <- base::invokeRestart
[17:29:25.115]             length <- base::length
[17:29:25.115]             list <- base::list
[17:29:25.115]             seq.int <- base::seq.int
[17:29:25.115]             signalCondition <- base::signalCondition
[17:29:25.115]             sys.calls <- base::sys.calls
[17:29:25.115]             `[[` <- base::`[[`
[17:29:25.115]             `+` <- base::`+`
[17:29:25.115]             `<<-` <- base::`<<-`
[17:29:25.115]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:25.115]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:25.115]                   3L)]
[17:29:25.115]             }
[17:29:25.115]             function(cond) {
[17:29:25.115]                 is_error <- inherits(cond, "error")
[17:29:25.115]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:25.115]                   NULL)
[17:29:25.115]                 if (is_error) {
[17:29:25.115]                   sessionInformation <- function() {
[17:29:25.115]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:25.115]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:25.115]                       search = base::search(), system = base::Sys.info())
[17:29:25.115]                   }
[17:29:25.115]                   ...future.conditions[[length(...future.conditions) + 
[17:29:25.115]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:25.115]                     cond$call), session = sessionInformation(), 
[17:29:25.115]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:25.115]                   signalCondition(cond)
[17:29:25.115]                 }
[17:29:25.115]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:25.115]                 "immediateCondition"))) {
[17:29:25.115]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:25.115]                   ...future.conditions[[length(...future.conditions) + 
[17:29:25.115]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:25.115]                   if (TRUE && !signal) {
[17:29:25.115]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:25.115]                     {
[17:29:25.115]                       inherits <- base::inherits
[17:29:25.115]                       invokeRestart <- base::invokeRestart
[17:29:25.115]                       is.null <- base::is.null
[17:29:25.115]                       muffled <- FALSE
[17:29:25.115]                       if (inherits(cond, "message")) {
[17:29:25.115]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:25.115]                         if (muffled) 
[17:29:25.115]                           invokeRestart("muffleMessage")
[17:29:25.115]                       }
[17:29:25.115]                       else if (inherits(cond, "warning")) {
[17:29:25.115]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:25.115]                         if (muffled) 
[17:29:25.115]                           invokeRestart("muffleWarning")
[17:29:25.115]                       }
[17:29:25.115]                       else if (inherits(cond, "condition")) {
[17:29:25.115]                         if (!is.null(pattern)) {
[17:29:25.115]                           computeRestarts <- base::computeRestarts
[17:29:25.115]                           grepl <- base::grepl
[17:29:25.115]                           restarts <- computeRestarts(cond)
[17:29:25.115]                           for (restart in restarts) {
[17:29:25.115]                             name <- restart$name
[17:29:25.115]                             if (is.null(name)) 
[17:29:25.115]                               next
[17:29:25.115]                             if (!grepl(pattern, name)) 
[17:29:25.115]                               next
[17:29:25.115]                             invokeRestart(restart)
[17:29:25.115]                             muffled <- TRUE
[17:29:25.115]                             break
[17:29:25.115]                           }
[17:29:25.115]                         }
[17:29:25.115]                       }
[17:29:25.115]                       invisible(muffled)
[17:29:25.115]                     }
[17:29:25.115]                     muffleCondition(cond, pattern = "^muffle")
[17:29:25.115]                   }
[17:29:25.115]                 }
[17:29:25.115]                 else {
[17:29:25.115]                   if (TRUE) {
[17:29:25.115]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:25.115]                     {
[17:29:25.115]                       inherits <- base::inherits
[17:29:25.115]                       invokeRestart <- base::invokeRestart
[17:29:25.115]                       is.null <- base::is.null
[17:29:25.115]                       muffled <- FALSE
[17:29:25.115]                       if (inherits(cond, "message")) {
[17:29:25.115]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:25.115]                         if (muffled) 
[17:29:25.115]                           invokeRestart("muffleMessage")
[17:29:25.115]                       }
[17:29:25.115]                       else if (inherits(cond, "warning")) {
[17:29:25.115]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:25.115]                         if (muffled) 
[17:29:25.115]                           invokeRestart("muffleWarning")
[17:29:25.115]                       }
[17:29:25.115]                       else if (inherits(cond, "condition")) {
[17:29:25.115]                         if (!is.null(pattern)) {
[17:29:25.115]                           computeRestarts <- base::computeRestarts
[17:29:25.115]                           grepl <- base::grepl
[17:29:25.115]                           restarts <- computeRestarts(cond)
[17:29:25.115]                           for (restart in restarts) {
[17:29:25.115]                             name <- restart$name
[17:29:25.115]                             if (is.null(name)) 
[17:29:25.115]                               next
[17:29:25.115]                             if (!grepl(pattern, name)) 
[17:29:25.115]                               next
[17:29:25.115]                             invokeRestart(restart)
[17:29:25.115]                             muffled <- TRUE
[17:29:25.115]                             break
[17:29:25.115]                           }
[17:29:25.115]                         }
[17:29:25.115]                       }
[17:29:25.115]                       invisible(muffled)
[17:29:25.115]                     }
[17:29:25.115]                     muffleCondition(cond, pattern = "^muffle")
[17:29:25.115]                   }
[17:29:25.115]                 }
[17:29:25.115]             }
[17:29:25.115]         }))
[17:29:25.115]     }, error = function(ex) {
[17:29:25.115]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:25.115]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:25.115]                 ...future.rng), started = ...future.startTime, 
[17:29:25.115]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:25.115]             version = "1.8"), class = "FutureResult")
[17:29:25.115]     }, finally = {
[17:29:25.115]         if (!identical(...future.workdir, getwd())) 
[17:29:25.115]             setwd(...future.workdir)
[17:29:25.115]         {
[17:29:25.115]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:25.115]                 ...future.oldOptions$nwarnings <- NULL
[17:29:25.115]             }
[17:29:25.115]             base::options(...future.oldOptions)
[17:29:25.115]             if (.Platform$OS.type == "windows") {
[17:29:25.115]                 old_names <- names(...future.oldEnvVars)
[17:29:25.115]                 envs <- base::Sys.getenv()
[17:29:25.115]                 names <- names(envs)
[17:29:25.115]                 common <- intersect(names, old_names)
[17:29:25.115]                 added <- setdiff(names, old_names)
[17:29:25.115]                 removed <- setdiff(old_names, names)
[17:29:25.115]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:25.115]                   envs[common]]
[17:29:25.115]                 NAMES <- toupper(changed)
[17:29:25.115]                 args <- list()
[17:29:25.115]                 for (kk in seq_along(NAMES)) {
[17:29:25.115]                   name <- changed[[kk]]
[17:29:25.115]                   NAME <- NAMES[[kk]]
[17:29:25.115]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:25.115]                     next
[17:29:25.115]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:25.115]                 }
[17:29:25.115]                 NAMES <- toupper(added)
[17:29:25.115]                 for (kk in seq_along(NAMES)) {
[17:29:25.115]                   name <- added[[kk]]
[17:29:25.115]                   NAME <- NAMES[[kk]]
[17:29:25.115]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:25.115]                     next
[17:29:25.115]                   args[[name]] <- ""
[17:29:25.115]                 }
[17:29:25.115]                 NAMES <- toupper(removed)
[17:29:25.115]                 for (kk in seq_along(NAMES)) {
[17:29:25.115]                   name <- removed[[kk]]
[17:29:25.115]                   NAME <- NAMES[[kk]]
[17:29:25.115]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:25.115]                     next
[17:29:25.115]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:25.115]                 }
[17:29:25.115]                 if (length(args) > 0) 
[17:29:25.115]                   base::do.call(base::Sys.setenv, args = args)
[17:29:25.115]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:25.115]             }
[17:29:25.115]             else {
[17:29:25.115]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:25.115]             }
[17:29:25.115]             {
[17:29:25.115]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:25.115]                   0L) {
[17:29:25.115]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:25.115]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:25.115]                   base::options(opts)
[17:29:25.115]                 }
[17:29:25.115]                 {
[17:29:25.115]                   {
[17:29:25.115]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:25.115]                     NULL
[17:29:25.115]                   }
[17:29:25.115]                   options(future.plan = NULL)
[17:29:25.115]                   if (is.na(NA_character_)) 
[17:29:25.115]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:25.115]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:25.115]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:25.115]                     .init = FALSE)
[17:29:25.115]                 }
[17:29:25.115]             }
[17:29:25.115]         }
[17:29:25.115]     })
[17:29:25.115]     if (TRUE) {
[17:29:25.115]         base::sink(type = "output", split = FALSE)
[17:29:25.115]         if (TRUE) {
[17:29:25.115]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:25.115]         }
[17:29:25.115]         else {
[17:29:25.115]             ...future.result["stdout"] <- base::list(NULL)
[17:29:25.115]         }
[17:29:25.115]         base::close(...future.stdout)
[17:29:25.115]         ...future.stdout <- NULL
[17:29:25.115]     }
[17:29:25.115]     ...future.result$conditions <- ...future.conditions
[17:29:25.115]     ...future.result$finished <- base::Sys.time()
[17:29:25.115]     ...future.result
[17:29:25.115] }
[17:29:25.122] Poll #1 (0): usedNodes() = 2, workers = 2
[17:29:25.183] receiveMessageFromWorker() for ClusterFuture ...
[17:29:25.184] - Validating connection of MultisessionFuture
[17:29:25.184] - received message: FutureResult
[17:29:25.185] - Received FutureResult
[17:29:25.185] - Erased future from FutureRegistry
[17:29:25.185] result() for ClusterFuture ...
[17:29:25.186] - result already collected: FutureResult
[17:29:25.186] result() for ClusterFuture ... done
[17:29:25.186] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:25.187] result() for ClusterFuture ...
[17:29:25.187] - result already collected: FutureResult
[17:29:25.187] result() for ClusterFuture ... done
[17:29:25.188] result() for ClusterFuture ...
[17:29:25.188] - result already collected: FutureResult
[17:29:25.188] result() for ClusterFuture ... done
[17:29:25.190] Exporting 1 global objects (340 bytes) to cluster node #1 ...
[17:29:25.190] Exporting 'kk' (35 bytes) to cluster node #1 ...
[17:29:25.191] Exporting 'kk' (35 bytes) to cluster node #1 ... DONE
[17:29:25.191] Exporting 1 global objects (340 bytes) to cluster node #1 ... DONE
[17:29:25.192] MultisessionFuture started
[17:29:25.192] - Launch lazy future ... done
[17:29:25.193] run() for 'MultisessionFuture' ... done
[17:29:25.193] resolve() on list ...
[17:29:25.193]  recursive: 0
[17:29:25.193]  length: 3
[17:29:25.194] 
[17:29:25.194] Future #1
[17:29:25.194]  length: 2 (resolved future 1)
[17:29:25.205] receiveMessageFromWorker() for ClusterFuture ...
[17:29:25.206] - Validating connection of MultisessionFuture
[17:29:25.206] - received message: FutureResult
[17:29:25.207] - Received FutureResult
[17:29:25.207] - Erased future from FutureRegistry
[17:29:25.207] result() for ClusterFuture ...
[17:29:25.207] - result already collected: FutureResult
[17:29:25.207] result() for ClusterFuture ... done
[17:29:25.208] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:25.208] Future #2
[17:29:25.208]  length: 1 (resolved future 2)
[17:29:25.329] receiveMessageFromWorker() for ClusterFuture ...
[17:29:25.329] - Validating connection of MultisessionFuture
[17:29:25.330] - received message: FutureResult
[17:29:25.330] - Received FutureResult
[17:29:25.330] - Erased future from FutureRegistry
[17:29:25.330] result() for ClusterFuture ...
[17:29:25.330] - result already collected: FutureResult
[17:29:25.331] result() for ClusterFuture ... done
[17:29:25.331] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:25.331] Future #3
[17:29:25.332]  length: 0 (resolved future 3)
[17:29:25.332] resolve() on list ... DONE
[17:29:25.332] getGlobalsAndPackages() ...
[17:29:25.332] Searching for globals...
[17:29:25.335] - globals found: [3] '{', 'Sys.sleep', 'kk'
[17:29:25.335] Searching for globals ... DONE
[17:29:25.336] Resolving globals: FALSE
[17:29:25.336] The total size of the 1 globals is 35 bytes (35 bytes)
[17:29:25.337] The total size of the 1 globals exported for future expression ('{; Sys.sleep(0.1); kk; }') is 35 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'kk' (35 bytes of class 'numeric')
[17:29:25.338] - globals: [1] 'kk'
[17:29:25.338] 
[17:29:25.338] getGlobalsAndPackages() ... DONE
[17:29:25.339] getGlobalsAndPackages() ...
[17:29:25.339] Searching for globals...
[17:29:25.341] - globals found: [3] '{', 'Sys.sleep', 'kk'
[17:29:25.342] Searching for globals ... DONE
[17:29:25.342] Resolving globals: FALSE
[17:29:25.343] The total size of the 1 globals is 35 bytes (35 bytes)
[17:29:25.344] The total size of the 1 globals exported for future expression ('{; Sys.sleep(0.1); kk; }') is 35 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'kk' (35 bytes of class 'numeric')
[17:29:25.344] - globals: [1] 'kk'
[17:29:25.344] 
[17:29:25.345] getGlobalsAndPackages() ... DONE
[17:29:25.345] getGlobalsAndPackages() ...
[17:29:25.346] Searching for globals...
[17:29:25.348] - globals found: [3] '{', 'Sys.sleep', 'kk'
[17:29:25.348] Searching for globals ... DONE
[17:29:25.348] Resolving globals: FALSE
[17:29:25.349] The total size of the 1 globals is 35 bytes (35 bytes)
[17:29:25.349] The total size of the 1 globals exported for future expression ('{; Sys.sleep(0.1); kk; }') is 35 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'kk' (35 bytes of class 'numeric')
[17:29:25.350] - globals: [1] 'kk'
[17:29:25.350] 
[17:29:25.350] getGlobalsAndPackages() ... DONE
[17:29:25.350] resolve() on list ...
[17:29:25.351]  recursive: 0
[17:29:25.351]  length: 3
[17:29:25.351] 
[17:29:25.351] run() for 'Future' ...
[17:29:25.352] - state: 'created'
[17:29:25.352] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:25.373] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:25.373] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:25.374]   - Field: 'node'
[17:29:25.374]   - Field: 'label'
[17:29:25.375]   - Field: 'local'
[17:29:25.375]   - Field: 'owner'
[17:29:25.375]   - Field: 'envir'
[17:29:25.376]   - Field: 'workers'
[17:29:25.376]   - Field: 'packages'
[17:29:25.376]   - Field: 'gc'
[17:29:25.377]   - Field: 'conditions'
[17:29:25.377]   - Field: 'persistent'
[17:29:25.377]   - Field: 'expr'
[17:29:25.377]   - Field: 'uuid'
[17:29:25.378]   - Field: 'seed'
[17:29:25.378]   - Field: 'version'
[17:29:25.379]   - Field: 'result'
[17:29:25.379]   - Field: 'asynchronous'
[17:29:25.379]   - Field: 'calls'
[17:29:25.380]   - Field: 'globals'
[17:29:25.380]   - Field: 'stdout'
[17:29:25.380]   - Field: 'earlySignal'
[17:29:25.381]   - Field: 'lazy'
[17:29:25.381]   - Field: 'state'
[17:29:25.381] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:25.382] - Launch lazy future ...
[17:29:25.382] Packages needed by the future expression (n = 0): <none>
[17:29:25.383] Packages needed by future strategies (n = 0): <none>
[17:29:25.384] {
[17:29:25.384]     {
[17:29:25.384]         {
[17:29:25.384]             ...future.startTime <- base::Sys.time()
[17:29:25.384]             {
[17:29:25.384]                 {
[17:29:25.384]                   {
[17:29:25.384]                     {
[17:29:25.384]                       base::local({
[17:29:25.384]                         has_future <- base::requireNamespace("future", 
[17:29:25.384]                           quietly = TRUE)
[17:29:25.384]                         if (has_future) {
[17:29:25.384]                           ns <- base::getNamespace("future")
[17:29:25.384]                           version <- ns[[".package"]][["version"]]
[17:29:25.384]                           if (is.null(version)) 
[17:29:25.384]                             version <- utils::packageVersion("future")
[17:29:25.384]                         }
[17:29:25.384]                         else {
[17:29:25.384]                           version <- NULL
[17:29:25.384]                         }
[17:29:25.384]                         if (!has_future || version < "1.8.0") {
[17:29:25.384]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:25.384]                             "", base::R.version$version.string), 
[17:29:25.384]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:25.384]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:25.384]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:25.384]                               "release", "version")], collapse = " "), 
[17:29:25.384]                             hostname = base::Sys.info()[["nodename"]])
[17:29:25.384]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:25.384]                             info)
[17:29:25.384]                           info <- base::paste(info, collapse = "; ")
[17:29:25.384]                           if (!has_future) {
[17:29:25.384]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:25.384]                               info)
[17:29:25.384]                           }
[17:29:25.384]                           else {
[17:29:25.384]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:25.384]                               info, version)
[17:29:25.384]                           }
[17:29:25.384]                           base::stop(msg)
[17:29:25.384]                         }
[17:29:25.384]                       })
[17:29:25.384]                     }
[17:29:25.384]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:25.384]                     base::options(mc.cores = 1L)
[17:29:25.384]                   }
[17:29:25.384]                   ...future.strategy.old <- future::plan("list")
[17:29:25.384]                   options(future.plan = NULL)
[17:29:25.384]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:25.384]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:25.384]                 }
[17:29:25.384]                 ...future.workdir <- getwd()
[17:29:25.384]             }
[17:29:25.384]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:25.384]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:25.384]         }
[17:29:25.384]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:25.384]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:25.384]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:25.384]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:25.384]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:25.384]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:25.384]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:25.384]             base::names(...future.oldOptions))
[17:29:25.384]     }
[17:29:25.384]     if (FALSE) {
[17:29:25.384]     }
[17:29:25.384]     else {
[17:29:25.384]         if (TRUE) {
[17:29:25.384]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:25.384]                 open = "w")
[17:29:25.384]         }
[17:29:25.384]         else {
[17:29:25.384]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:25.384]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:25.384]         }
[17:29:25.384]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:25.384]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:25.384]             base::sink(type = "output", split = FALSE)
[17:29:25.384]             base::close(...future.stdout)
[17:29:25.384]         }, add = TRUE)
[17:29:25.384]     }
[17:29:25.384]     ...future.frame <- base::sys.nframe()
[17:29:25.384]     ...future.conditions <- base::list()
[17:29:25.384]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:25.384]     if (FALSE) {
[17:29:25.384]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:25.384]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:25.384]     }
[17:29:25.384]     ...future.result <- base::tryCatch({
[17:29:25.384]         base::withCallingHandlers({
[17:29:25.384]             ...future.value <- base::withVisible(base::local({
[17:29:25.384]                 ...future.makeSendCondition <- base::local({
[17:29:25.384]                   sendCondition <- NULL
[17:29:25.384]                   function(frame = 1L) {
[17:29:25.384]                     if (is.function(sendCondition)) 
[17:29:25.384]                       return(sendCondition)
[17:29:25.384]                     ns <- getNamespace("parallel")
[17:29:25.384]                     if (exists("sendData", mode = "function", 
[17:29:25.384]                       envir = ns)) {
[17:29:25.384]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:25.384]                         envir = ns)
[17:29:25.384]                       envir <- sys.frame(frame)
[17:29:25.384]                       master <- NULL
[17:29:25.384]                       while (!identical(envir, .GlobalEnv) && 
[17:29:25.384]                         !identical(envir, emptyenv())) {
[17:29:25.384]                         if (exists("master", mode = "list", envir = envir, 
[17:29:25.384]                           inherits = FALSE)) {
[17:29:25.384]                           master <- get("master", mode = "list", 
[17:29:25.384]                             envir = envir, inherits = FALSE)
[17:29:25.384]                           if (inherits(master, c("SOCKnode", 
[17:29:25.384]                             "SOCK0node"))) {
[17:29:25.384]                             sendCondition <<- function(cond) {
[17:29:25.384]                               data <- list(type = "VALUE", value = cond, 
[17:29:25.384]                                 success = TRUE)
[17:29:25.384]                               parallel_sendData(master, data)
[17:29:25.384]                             }
[17:29:25.384]                             return(sendCondition)
[17:29:25.384]                           }
[17:29:25.384]                         }
[17:29:25.384]                         frame <- frame + 1L
[17:29:25.384]                         envir <- sys.frame(frame)
[17:29:25.384]                       }
[17:29:25.384]                     }
[17:29:25.384]                     sendCondition <<- function(cond) NULL
[17:29:25.384]                   }
[17:29:25.384]                 })
[17:29:25.384]                 withCallingHandlers({
[17:29:25.384]                   {
[17:29:25.384]                     Sys.sleep(0.1)
[17:29:25.384]                     kk
[17:29:25.384]                   }
[17:29:25.384]                 }, immediateCondition = function(cond) {
[17:29:25.384]                   sendCondition <- ...future.makeSendCondition()
[17:29:25.384]                   sendCondition(cond)
[17:29:25.384]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:25.384]                   {
[17:29:25.384]                     inherits <- base::inherits
[17:29:25.384]                     invokeRestart <- base::invokeRestart
[17:29:25.384]                     is.null <- base::is.null
[17:29:25.384]                     muffled <- FALSE
[17:29:25.384]                     if (inherits(cond, "message")) {
[17:29:25.384]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:25.384]                       if (muffled) 
[17:29:25.384]                         invokeRestart("muffleMessage")
[17:29:25.384]                     }
[17:29:25.384]                     else if (inherits(cond, "warning")) {
[17:29:25.384]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:25.384]                       if (muffled) 
[17:29:25.384]                         invokeRestart("muffleWarning")
[17:29:25.384]                     }
[17:29:25.384]                     else if (inherits(cond, "condition")) {
[17:29:25.384]                       if (!is.null(pattern)) {
[17:29:25.384]                         computeRestarts <- base::computeRestarts
[17:29:25.384]                         grepl <- base::grepl
[17:29:25.384]                         restarts <- computeRestarts(cond)
[17:29:25.384]                         for (restart in restarts) {
[17:29:25.384]                           name <- restart$name
[17:29:25.384]                           if (is.null(name)) 
[17:29:25.384]                             next
[17:29:25.384]                           if (!grepl(pattern, name)) 
[17:29:25.384]                             next
[17:29:25.384]                           invokeRestart(restart)
[17:29:25.384]                           muffled <- TRUE
[17:29:25.384]                           break
[17:29:25.384]                         }
[17:29:25.384]                       }
[17:29:25.384]                     }
[17:29:25.384]                     invisible(muffled)
[17:29:25.384]                   }
[17:29:25.384]                   muffleCondition(cond)
[17:29:25.384]                 })
[17:29:25.384]             }))
[17:29:25.384]             future::FutureResult(value = ...future.value$value, 
[17:29:25.384]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:25.384]                   ...future.rng), globalenv = if (FALSE) 
[17:29:25.384]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:25.384]                     ...future.globalenv.names))
[17:29:25.384]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:25.384]         }, condition = base::local({
[17:29:25.384]             c <- base::c
[17:29:25.384]             inherits <- base::inherits
[17:29:25.384]             invokeRestart <- base::invokeRestart
[17:29:25.384]             length <- base::length
[17:29:25.384]             list <- base::list
[17:29:25.384]             seq.int <- base::seq.int
[17:29:25.384]             signalCondition <- base::signalCondition
[17:29:25.384]             sys.calls <- base::sys.calls
[17:29:25.384]             `[[` <- base::`[[`
[17:29:25.384]             `+` <- base::`+`
[17:29:25.384]             `<<-` <- base::`<<-`
[17:29:25.384]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:25.384]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:25.384]                   3L)]
[17:29:25.384]             }
[17:29:25.384]             function(cond) {
[17:29:25.384]                 is_error <- inherits(cond, "error")
[17:29:25.384]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:25.384]                   NULL)
[17:29:25.384]                 if (is_error) {
[17:29:25.384]                   sessionInformation <- function() {
[17:29:25.384]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:25.384]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:25.384]                       search = base::search(), system = base::Sys.info())
[17:29:25.384]                   }
[17:29:25.384]                   ...future.conditions[[length(...future.conditions) + 
[17:29:25.384]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:25.384]                     cond$call), session = sessionInformation(), 
[17:29:25.384]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:25.384]                   signalCondition(cond)
[17:29:25.384]                 }
[17:29:25.384]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:25.384]                 "immediateCondition"))) {
[17:29:25.384]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:25.384]                   ...future.conditions[[length(...future.conditions) + 
[17:29:25.384]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:25.384]                   if (TRUE && !signal) {
[17:29:25.384]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:25.384]                     {
[17:29:25.384]                       inherits <- base::inherits
[17:29:25.384]                       invokeRestart <- base::invokeRestart
[17:29:25.384]                       is.null <- base::is.null
[17:29:25.384]                       muffled <- FALSE
[17:29:25.384]                       if (inherits(cond, "message")) {
[17:29:25.384]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:25.384]                         if (muffled) 
[17:29:25.384]                           invokeRestart("muffleMessage")
[17:29:25.384]                       }
[17:29:25.384]                       else if (inherits(cond, "warning")) {
[17:29:25.384]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:25.384]                         if (muffled) 
[17:29:25.384]                           invokeRestart("muffleWarning")
[17:29:25.384]                       }
[17:29:25.384]                       else if (inherits(cond, "condition")) {
[17:29:25.384]                         if (!is.null(pattern)) {
[17:29:25.384]                           computeRestarts <- base::computeRestarts
[17:29:25.384]                           grepl <- base::grepl
[17:29:25.384]                           restarts <- computeRestarts(cond)
[17:29:25.384]                           for (restart in restarts) {
[17:29:25.384]                             name <- restart$name
[17:29:25.384]                             if (is.null(name)) 
[17:29:25.384]                               next
[17:29:25.384]                             if (!grepl(pattern, name)) 
[17:29:25.384]                               next
[17:29:25.384]                             invokeRestart(restart)
[17:29:25.384]                             muffled <- TRUE
[17:29:25.384]                             break
[17:29:25.384]                           }
[17:29:25.384]                         }
[17:29:25.384]                       }
[17:29:25.384]                       invisible(muffled)
[17:29:25.384]                     }
[17:29:25.384]                     muffleCondition(cond, pattern = "^muffle")
[17:29:25.384]                   }
[17:29:25.384]                 }
[17:29:25.384]                 else {
[17:29:25.384]                   if (TRUE) {
[17:29:25.384]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:25.384]                     {
[17:29:25.384]                       inherits <- base::inherits
[17:29:25.384]                       invokeRestart <- base::invokeRestart
[17:29:25.384]                       is.null <- base::is.null
[17:29:25.384]                       muffled <- FALSE
[17:29:25.384]                       if (inherits(cond, "message")) {
[17:29:25.384]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:25.384]                         if (muffled) 
[17:29:25.384]                           invokeRestart("muffleMessage")
[17:29:25.384]                       }
[17:29:25.384]                       else if (inherits(cond, "warning")) {
[17:29:25.384]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:25.384]                         if (muffled) 
[17:29:25.384]                           invokeRestart("muffleWarning")
[17:29:25.384]                       }
[17:29:25.384]                       else if (inherits(cond, "condition")) {
[17:29:25.384]                         if (!is.null(pattern)) {
[17:29:25.384]                           computeRestarts <- base::computeRestarts
[17:29:25.384]                           grepl <- base::grepl
[17:29:25.384]                           restarts <- computeRestarts(cond)
[17:29:25.384]                           for (restart in restarts) {
[17:29:25.384]                             name <- restart$name
[17:29:25.384]                             if (is.null(name)) 
[17:29:25.384]                               next
[17:29:25.384]                             if (!grepl(pattern, name)) 
[17:29:25.384]                               next
[17:29:25.384]                             invokeRestart(restart)
[17:29:25.384]                             muffled <- TRUE
[17:29:25.384]                             break
[17:29:25.384]                           }
[17:29:25.384]                         }
[17:29:25.384]                       }
[17:29:25.384]                       invisible(muffled)
[17:29:25.384]                     }
[17:29:25.384]                     muffleCondition(cond, pattern = "^muffle")
[17:29:25.384]                   }
[17:29:25.384]                 }
[17:29:25.384]             }
[17:29:25.384]         }))
[17:29:25.384]     }, error = function(ex) {
[17:29:25.384]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:25.384]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:25.384]                 ...future.rng), started = ...future.startTime, 
[17:29:25.384]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:25.384]             version = "1.8"), class = "FutureResult")
[17:29:25.384]     }, finally = {
[17:29:25.384]         if (!identical(...future.workdir, getwd())) 
[17:29:25.384]             setwd(...future.workdir)
[17:29:25.384]         {
[17:29:25.384]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:25.384]                 ...future.oldOptions$nwarnings <- NULL
[17:29:25.384]             }
[17:29:25.384]             base::options(...future.oldOptions)
[17:29:25.384]             if (.Platform$OS.type == "windows") {
[17:29:25.384]                 old_names <- names(...future.oldEnvVars)
[17:29:25.384]                 envs <- base::Sys.getenv()
[17:29:25.384]                 names <- names(envs)
[17:29:25.384]                 common <- intersect(names, old_names)
[17:29:25.384]                 added <- setdiff(names, old_names)
[17:29:25.384]                 removed <- setdiff(old_names, names)
[17:29:25.384]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:25.384]                   envs[common]]
[17:29:25.384]                 NAMES <- toupper(changed)
[17:29:25.384]                 args <- list()
[17:29:25.384]                 for (kk in seq_along(NAMES)) {
[17:29:25.384]                   name <- changed[[kk]]
[17:29:25.384]                   NAME <- NAMES[[kk]]
[17:29:25.384]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:25.384]                     next
[17:29:25.384]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:25.384]                 }
[17:29:25.384]                 NAMES <- toupper(added)
[17:29:25.384]                 for (kk in seq_along(NAMES)) {
[17:29:25.384]                   name <- added[[kk]]
[17:29:25.384]                   NAME <- NAMES[[kk]]
[17:29:25.384]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:25.384]                     next
[17:29:25.384]                   args[[name]] <- ""
[17:29:25.384]                 }
[17:29:25.384]                 NAMES <- toupper(removed)
[17:29:25.384]                 for (kk in seq_along(NAMES)) {
[17:29:25.384]                   name <- removed[[kk]]
[17:29:25.384]                   NAME <- NAMES[[kk]]
[17:29:25.384]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:25.384]                     next
[17:29:25.384]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:25.384]                 }
[17:29:25.384]                 if (length(args) > 0) 
[17:29:25.384]                   base::do.call(base::Sys.setenv, args = args)
[17:29:25.384]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:25.384]             }
[17:29:25.384]             else {
[17:29:25.384]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:25.384]             }
[17:29:25.384]             {
[17:29:25.384]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:25.384]                   0L) {
[17:29:25.384]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:25.384]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:25.384]                   base::options(opts)
[17:29:25.384]                 }
[17:29:25.384]                 {
[17:29:25.384]                   {
[17:29:25.384]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:25.384]                     NULL
[17:29:25.384]                   }
[17:29:25.384]                   options(future.plan = NULL)
[17:29:25.384]                   if (is.na(NA_character_)) 
[17:29:25.384]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:25.384]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:25.384]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:25.384]                     .init = FALSE)
[17:29:25.384]                 }
[17:29:25.384]             }
[17:29:25.384]         }
[17:29:25.384]     })
[17:29:25.384]     if (TRUE) {
[17:29:25.384]         base::sink(type = "output", split = FALSE)
[17:29:25.384]         if (TRUE) {
[17:29:25.384]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:25.384]         }
[17:29:25.384]         else {
[17:29:25.384]             ...future.result["stdout"] <- base::list(NULL)
[17:29:25.384]         }
[17:29:25.384]         base::close(...future.stdout)
[17:29:25.384]         ...future.stdout <- NULL
[17:29:25.384]     }
[17:29:25.384]     ...future.result$conditions <- ...future.conditions
[17:29:25.384]     ...future.result$finished <- base::Sys.time()
[17:29:25.384]     ...future.result
[17:29:25.384] }
[17:29:25.394] Exporting 1 global objects (340 bytes) to cluster node #1 ...
[17:29:25.394] Exporting 'kk' (35 bytes) to cluster node #1 ...
[17:29:25.395] Exporting 'kk' (35 bytes) to cluster node #1 ... DONE
[17:29:25.395] Exporting 1 global objects (340 bytes) to cluster node #1 ... DONE
[17:29:25.396] MultisessionFuture started
[17:29:25.397] - Launch lazy future ... done
[17:29:25.397] run() for 'MultisessionFuture' ... done
[17:29:25.519] receiveMessageFromWorker() for ClusterFuture ...
[17:29:25.520] - Validating connection of MultisessionFuture
[17:29:25.520] - received message: FutureResult
[17:29:25.520] - Received FutureResult
[17:29:25.520] - Erased future from FutureRegistry
[17:29:25.521] result() for ClusterFuture ...
[17:29:25.521] - result already collected: FutureResult
[17:29:25.521] result() for ClusterFuture ... done
[17:29:25.521] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:25.521] Future #1
[17:29:25.522]  length: 2 (resolved future 1)
[17:29:25.522] run() for 'Future' ...
[17:29:25.522] - state: 'created'
[17:29:25.522] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:25.539] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:25.539] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:25.539]   - Field: 'node'
[17:29:25.540]   - Field: 'label'
[17:29:25.540]   - Field: 'local'
[17:29:25.540]   - Field: 'owner'
[17:29:25.541]   - Field: 'envir'
[17:29:25.541]   - Field: 'workers'
[17:29:25.541]   - Field: 'packages'
[17:29:25.542]   - Field: 'gc'
[17:29:25.542]   - Field: 'conditions'
[17:29:25.542]   - Field: 'persistent'
[17:29:25.543]   - Field: 'expr'
[17:29:25.543]   - Field: 'uuid'
[17:29:25.543]   - Field: 'seed'
[17:29:25.543]   - Field: 'version'
[17:29:25.544]   - Field: 'result'
[17:29:25.544]   - Field: 'asynchronous'
[17:29:25.544]   - Field: 'calls'
[17:29:25.544]   - Field: 'globals'
[17:29:25.544]   - Field: 'stdout'
[17:29:25.544]   - Field: 'earlySignal'
[17:29:25.545]   - Field: 'lazy'
[17:29:25.545]   - Field: 'state'
[17:29:25.545] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:25.546] - Launch lazy future ...
[17:29:25.549] Packages needed by the future expression (n = 0): <none>
[17:29:25.549] Packages needed by future strategies (n = 0): <none>
[17:29:25.550] {
[17:29:25.550]     {
[17:29:25.550]         {
[17:29:25.550]             ...future.startTime <- base::Sys.time()
[17:29:25.550]             {
[17:29:25.550]                 {
[17:29:25.550]                   {
[17:29:25.550]                     {
[17:29:25.550]                       base::local({
[17:29:25.550]                         has_future <- base::requireNamespace("future", 
[17:29:25.550]                           quietly = TRUE)
[17:29:25.550]                         if (has_future) {
[17:29:25.550]                           ns <- base::getNamespace("future")
[17:29:25.550]                           version <- ns[[".package"]][["version"]]
[17:29:25.550]                           if (is.null(version)) 
[17:29:25.550]                             version <- utils::packageVersion("future")
[17:29:25.550]                         }
[17:29:25.550]                         else {
[17:29:25.550]                           version <- NULL
[17:29:25.550]                         }
[17:29:25.550]                         if (!has_future || version < "1.8.0") {
[17:29:25.550]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:25.550]                             "", base::R.version$version.string), 
[17:29:25.550]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:25.550]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:25.550]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:25.550]                               "release", "version")], collapse = " "), 
[17:29:25.550]                             hostname = base::Sys.info()[["nodename"]])
[17:29:25.550]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:25.550]                             info)
[17:29:25.550]                           info <- base::paste(info, collapse = "; ")
[17:29:25.550]                           if (!has_future) {
[17:29:25.550]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:25.550]                               info)
[17:29:25.550]                           }
[17:29:25.550]                           else {
[17:29:25.550]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:25.550]                               info, version)
[17:29:25.550]                           }
[17:29:25.550]                           base::stop(msg)
[17:29:25.550]                         }
[17:29:25.550]                       })
[17:29:25.550]                     }
[17:29:25.550]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:25.550]                     base::options(mc.cores = 1L)
[17:29:25.550]                   }
[17:29:25.550]                   ...future.strategy.old <- future::plan("list")
[17:29:25.550]                   options(future.plan = NULL)
[17:29:25.550]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:25.550]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:25.550]                 }
[17:29:25.550]                 ...future.workdir <- getwd()
[17:29:25.550]             }
[17:29:25.550]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:25.550]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:25.550]         }
[17:29:25.550]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:25.550]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:25.550]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:25.550]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:25.550]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:25.550]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:25.550]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:25.550]             base::names(...future.oldOptions))
[17:29:25.550]     }
[17:29:25.550]     if (FALSE) {
[17:29:25.550]     }
[17:29:25.550]     else {
[17:29:25.550]         if (TRUE) {
[17:29:25.550]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:25.550]                 open = "w")
[17:29:25.550]         }
[17:29:25.550]         else {
[17:29:25.550]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:25.550]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:25.550]         }
[17:29:25.550]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:25.550]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:25.550]             base::sink(type = "output", split = FALSE)
[17:29:25.550]             base::close(...future.stdout)
[17:29:25.550]         }, add = TRUE)
[17:29:25.550]     }
[17:29:25.550]     ...future.frame <- base::sys.nframe()
[17:29:25.550]     ...future.conditions <- base::list()
[17:29:25.550]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:25.550]     if (FALSE) {
[17:29:25.550]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:25.550]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:25.550]     }
[17:29:25.550]     ...future.result <- base::tryCatch({
[17:29:25.550]         base::withCallingHandlers({
[17:29:25.550]             ...future.value <- base::withVisible(base::local({
[17:29:25.550]                 ...future.makeSendCondition <- base::local({
[17:29:25.550]                   sendCondition <- NULL
[17:29:25.550]                   function(frame = 1L) {
[17:29:25.550]                     if (is.function(sendCondition)) 
[17:29:25.550]                       return(sendCondition)
[17:29:25.550]                     ns <- getNamespace("parallel")
[17:29:25.550]                     if (exists("sendData", mode = "function", 
[17:29:25.550]                       envir = ns)) {
[17:29:25.550]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:25.550]                         envir = ns)
[17:29:25.550]                       envir <- sys.frame(frame)
[17:29:25.550]                       master <- NULL
[17:29:25.550]                       while (!identical(envir, .GlobalEnv) && 
[17:29:25.550]                         !identical(envir, emptyenv())) {
[17:29:25.550]                         if (exists("master", mode = "list", envir = envir, 
[17:29:25.550]                           inherits = FALSE)) {
[17:29:25.550]                           master <- get("master", mode = "list", 
[17:29:25.550]                             envir = envir, inherits = FALSE)
[17:29:25.550]                           if (inherits(master, c("SOCKnode", 
[17:29:25.550]                             "SOCK0node"))) {
[17:29:25.550]                             sendCondition <<- function(cond) {
[17:29:25.550]                               data <- list(type = "VALUE", value = cond, 
[17:29:25.550]                                 success = TRUE)
[17:29:25.550]                               parallel_sendData(master, data)
[17:29:25.550]                             }
[17:29:25.550]                             return(sendCondition)
[17:29:25.550]                           }
[17:29:25.550]                         }
[17:29:25.550]                         frame <- frame + 1L
[17:29:25.550]                         envir <- sys.frame(frame)
[17:29:25.550]                       }
[17:29:25.550]                     }
[17:29:25.550]                     sendCondition <<- function(cond) NULL
[17:29:25.550]                   }
[17:29:25.550]                 })
[17:29:25.550]                 withCallingHandlers({
[17:29:25.550]                   {
[17:29:25.550]                     Sys.sleep(0.1)
[17:29:25.550]                     kk
[17:29:25.550]                   }
[17:29:25.550]                 }, immediateCondition = function(cond) {
[17:29:25.550]                   sendCondition <- ...future.makeSendCondition()
[17:29:25.550]                   sendCondition(cond)
[17:29:25.550]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:25.550]                   {
[17:29:25.550]                     inherits <- base::inherits
[17:29:25.550]                     invokeRestart <- base::invokeRestart
[17:29:25.550]                     is.null <- base::is.null
[17:29:25.550]                     muffled <- FALSE
[17:29:25.550]                     if (inherits(cond, "message")) {
[17:29:25.550]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:25.550]                       if (muffled) 
[17:29:25.550]                         invokeRestart("muffleMessage")
[17:29:25.550]                     }
[17:29:25.550]                     else if (inherits(cond, "warning")) {
[17:29:25.550]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:25.550]                       if (muffled) 
[17:29:25.550]                         invokeRestart("muffleWarning")
[17:29:25.550]                     }
[17:29:25.550]                     else if (inherits(cond, "condition")) {
[17:29:25.550]                       if (!is.null(pattern)) {
[17:29:25.550]                         computeRestarts <- base::computeRestarts
[17:29:25.550]                         grepl <- base::grepl
[17:29:25.550]                         restarts <- computeRestarts(cond)
[17:29:25.550]                         for (restart in restarts) {
[17:29:25.550]                           name <- restart$name
[17:29:25.550]                           if (is.null(name)) 
[17:29:25.550]                             next
[17:29:25.550]                           if (!grepl(pattern, name)) 
[17:29:25.550]                             next
[17:29:25.550]                           invokeRestart(restart)
[17:29:25.550]                           muffled <- TRUE
[17:29:25.550]                           break
[17:29:25.550]                         }
[17:29:25.550]                       }
[17:29:25.550]                     }
[17:29:25.550]                     invisible(muffled)
[17:29:25.550]                   }
[17:29:25.550]                   muffleCondition(cond)
[17:29:25.550]                 })
[17:29:25.550]             }))
[17:29:25.550]             future::FutureResult(value = ...future.value$value, 
[17:29:25.550]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:25.550]                   ...future.rng), globalenv = if (FALSE) 
[17:29:25.550]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:25.550]                     ...future.globalenv.names))
[17:29:25.550]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:25.550]         }, condition = base::local({
[17:29:25.550]             c <- base::c
[17:29:25.550]             inherits <- base::inherits
[17:29:25.550]             invokeRestart <- base::invokeRestart
[17:29:25.550]             length <- base::length
[17:29:25.550]             list <- base::list
[17:29:25.550]             seq.int <- base::seq.int
[17:29:25.550]             signalCondition <- base::signalCondition
[17:29:25.550]             sys.calls <- base::sys.calls
[17:29:25.550]             `[[` <- base::`[[`
[17:29:25.550]             `+` <- base::`+`
[17:29:25.550]             `<<-` <- base::`<<-`
[17:29:25.550]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:25.550]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:25.550]                   3L)]
[17:29:25.550]             }
[17:29:25.550]             function(cond) {
[17:29:25.550]                 is_error <- inherits(cond, "error")
[17:29:25.550]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:25.550]                   NULL)
[17:29:25.550]                 if (is_error) {
[17:29:25.550]                   sessionInformation <- function() {
[17:29:25.550]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:25.550]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:25.550]                       search = base::search(), system = base::Sys.info())
[17:29:25.550]                   }
[17:29:25.550]                   ...future.conditions[[length(...future.conditions) + 
[17:29:25.550]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:25.550]                     cond$call), session = sessionInformation(), 
[17:29:25.550]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:25.550]                   signalCondition(cond)
[17:29:25.550]                 }
[17:29:25.550]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:25.550]                 "immediateCondition"))) {
[17:29:25.550]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:25.550]                   ...future.conditions[[length(...future.conditions) + 
[17:29:25.550]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:25.550]                   if (TRUE && !signal) {
[17:29:25.550]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:25.550]                     {
[17:29:25.550]                       inherits <- base::inherits
[17:29:25.550]                       invokeRestart <- base::invokeRestart
[17:29:25.550]                       is.null <- base::is.null
[17:29:25.550]                       muffled <- FALSE
[17:29:25.550]                       if (inherits(cond, "message")) {
[17:29:25.550]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:25.550]                         if (muffled) 
[17:29:25.550]                           invokeRestart("muffleMessage")
[17:29:25.550]                       }
[17:29:25.550]                       else if (inherits(cond, "warning")) {
[17:29:25.550]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:25.550]                         if (muffled) 
[17:29:25.550]                           invokeRestart("muffleWarning")
[17:29:25.550]                       }
[17:29:25.550]                       else if (inherits(cond, "condition")) {
[17:29:25.550]                         if (!is.null(pattern)) {
[17:29:25.550]                           computeRestarts <- base::computeRestarts
[17:29:25.550]                           grepl <- base::grepl
[17:29:25.550]                           restarts <- computeRestarts(cond)
[17:29:25.550]                           for (restart in restarts) {
[17:29:25.550]                             name <- restart$name
[17:29:25.550]                             if (is.null(name)) 
[17:29:25.550]                               next
[17:29:25.550]                             if (!grepl(pattern, name)) 
[17:29:25.550]                               next
[17:29:25.550]                             invokeRestart(restart)
[17:29:25.550]                             muffled <- TRUE
[17:29:25.550]                             break
[17:29:25.550]                           }
[17:29:25.550]                         }
[17:29:25.550]                       }
[17:29:25.550]                       invisible(muffled)
[17:29:25.550]                     }
[17:29:25.550]                     muffleCondition(cond, pattern = "^muffle")
[17:29:25.550]                   }
[17:29:25.550]                 }
[17:29:25.550]                 else {
[17:29:25.550]                   if (TRUE) {
[17:29:25.550]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:25.550]                     {
[17:29:25.550]                       inherits <- base::inherits
[17:29:25.550]                       invokeRestart <- base::invokeRestart
[17:29:25.550]                       is.null <- base::is.null
[17:29:25.550]                       muffled <- FALSE
[17:29:25.550]                       if (inherits(cond, "message")) {
[17:29:25.550]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:25.550]                         if (muffled) 
[17:29:25.550]                           invokeRestart("muffleMessage")
[17:29:25.550]                       }
[17:29:25.550]                       else if (inherits(cond, "warning")) {
[17:29:25.550]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:25.550]                         if (muffled) 
[17:29:25.550]                           invokeRestart("muffleWarning")
[17:29:25.550]                       }
[17:29:25.550]                       else if (inherits(cond, "condition")) {
[17:29:25.550]                         if (!is.null(pattern)) {
[17:29:25.550]                           computeRestarts <- base::computeRestarts
[17:29:25.550]                           grepl <- base::grepl
[17:29:25.550]                           restarts <- computeRestarts(cond)
[17:29:25.550]                           for (restart in restarts) {
[17:29:25.550]                             name <- restart$name
[17:29:25.550]                             if (is.null(name)) 
[17:29:25.550]                               next
[17:29:25.550]                             if (!grepl(pattern, name)) 
[17:29:25.550]                               next
[17:29:25.550]                             invokeRestart(restart)
[17:29:25.550]                             muffled <- TRUE
[17:29:25.550]                             break
[17:29:25.550]                           }
[17:29:25.550]                         }
[17:29:25.550]                       }
[17:29:25.550]                       invisible(muffled)
[17:29:25.550]                     }
[17:29:25.550]                     muffleCondition(cond, pattern = "^muffle")
[17:29:25.550]                   }
[17:29:25.550]                 }
[17:29:25.550]             }
[17:29:25.550]         }))
[17:29:25.550]     }, error = function(ex) {
[17:29:25.550]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:25.550]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:25.550]                 ...future.rng), started = ...future.startTime, 
[17:29:25.550]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:25.550]             version = "1.8"), class = "FutureResult")
[17:29:25.550]     }, finally = {
[17:29:25.550]         if (!identical(...future.workdir, getwd())) 
[17:29:25.550]             setwd(...future.workdir)
[17:29:25.550]         {
[17:29:25.550]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:25.550]                 ...future.oldOptions$nwarnings <- NULL
[17:29:25.550]             }
[17:29:25.550]             base::options(...future.oldOptions)
[17:29:25.550]             if (.Platform$OS.type == "windows") {
[17:29:25.550]                 old_names <- names(...future.oldEnvVars)
[17:29:25.550]                 envs <- base::Sys.getenv()
[17:29:25.550]                 names <- names(envs)
[17:29:25.550]                 common <- intersect(names, old_names)
[17:29:25.550]                 added <- setdiff(names, old_names)
[17:29:25.550]                 removed <- setdiff(old_names, names)
[17:29:25.550]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:25.550]                   envs[common]]
[17:29:25.550]                 NAMES <- toupper(changed)
[17:29:25.550]                 args <- list()
[17:29:25.550]                 for (kk in seq_along(NAMES)) {
[17:29:25.550]                   name <- changed[[kk]]
[17:29:25.550]                   NAME <- NAMES[[kk]]
[17:29:25.550]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:25.550]                     next
[17:29:25.550]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:25.550]                 }
[17:29:25.550]                 NAMES <- toupper(added)
[17:29:25.550]                 for (kk in seq_along(NAMES)) {
[17:29:25.550]                   name <- added[[kk]]
[17:29:25.550]                   NAME <- NAMES[[kk]]
[17:29:25.550]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:25.550]                     next
[17:29:25.550]                   args[[name]] <- ""
[17:29:25.550]                 }
[17:29:25.550]                 NAMES <- toupper(removed)
[17:29:25.550]                 for (kk in seq_along(NAMES)) {
[17:29:25.550]                   name <- removed[[kk]]
[17:29:25.550]                   NAME <- NAMES[[kk]]
[17:29:25.550]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:25.550]                     next
[17:29:25.550]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:25.550]                 }
[17:29:25.550]                 if (length(args) > 0) 
[17:29:25.550]                   base::do.call(base::Sys.setenv, args = args)
[17:29:25.550]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:25.550]             }
[17:29:25.550]             else {
[17:29:25.550]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:25.550]             }
[17:29:25.550]             {
[17:29:25.550]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:25.550]                   0L) {
[17:29:25.550]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:25.550]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:25.550]                   base::options(opts)
[17:29:25.550]                 }
[17:29:25.550]                 {
[17:29:25.550]                   {
[17:29:25.550]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:25.550]                     NULL
[17:29:25.550]                   }
[17:29:25.550]                   options(future.plan = NULL)
[17:29:25.550]                   if (is.na(NA_character_)) 
[17:29:25.550]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:25.550]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:25.550]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:25.550]                     .init = FALSE)
[17:29:25.550]                 }
[17:29:25.550]             }
[17:29:25.550]         }
[17:29:25.550]     })
[17:29:25.550]     if (TRUE) {
[17:29:25.550]         base::sink(type = "output", split = FALSE)
[17:29:25.550]         if (TRUE) {
[17:29:25.550]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:25.550]         }
[17:29:25.550]         else {
[17:29:25.550]             ...future.result["stdout"] <- base::list(NULL)
[17:29:25.550]         }
[17:29:25.550]         base::close(...future.stdout)
[17:29:25.550]         ...future.stdout <- NULL
[17:29:25.550]     }
[17:29:25.550]     ...future.result$conditions <- ...future.conditions
[17:29:25.550]     ...future.result$finished <- base::Sys.time()
[17:29:25.550]     ...future.result
[17:29:25.550] }
[17:29:25.558] Exporting 1 global objects (340 bytes) to cluster node #1 ...
[17:29:25.558] Exporting 'kk' (35 bytes) to cluster node #1 ...
[17:29:25.559] Exporting 'kk' (35 bytes) to cluster node #1 ... DONE
[17:29:25.559] Exporting 1 global objects (340 bytes) to cluster node #1 ... DONE
[17:29:25.560] MultisessionFuture started
[17:29:25.561] - Launch lazy future ... done
[17:29:25.561] run() for 'MultisessionFuture' ... done
[17:29:25.702] receiveMessageFromWorker() for ClusterFuture ...
[17:29:25.703] - Validating connection of MultisessionFuture
[17:29:25.703] - received message: FutureResult
[17:29:25.703] - Received FutureResult
[17:29:25.703] - Erased future from FutureRegistry
[17:29:25.704] result() for ClusterFuture ...
[17:29:25.704] - result already collected: FutureResult
[17:29:25.704] result() for ClusterFuture ... done
[17:29:25.704] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:25.704] Future #2
[17:29:25.704]  length: 1 (resolved future 2)
[17:29:25.705] run() for 'Future' ...
[17:29:25.705] - state: 'created'
[17:29:25.705] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:25.723] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:25.723] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:25.724]   - Field: 'node'
[17:29:25.724]   - Field: 'label'
[17:29:25.724]   - Field: 'local'
[17:29:25.725]   - Field: 'owner'
[17:29:25.725]   - Field: 'envir'
[17:29:25.725]   - Field: 'workers'
[17:29:25.726]   - Field: 'packages'
[17:29:25.726]   - Field: 'gc'
[17:29:25.726]   - Field: 'conditions'
[17:29:25.727]   - Field: 'persistent'
[17:29:25.727]   - Field: 'expr'
[17:29:25.727]   - Field: 'uuid'
[17:29:25.727]   - Field: 'seed'
[17:29:25.728]   - Field: 'version'
[17:29:25.728]   - Field: 'result'
[17:29:25.728]   - Field: 'asynchronous'
[17:29:25.729]   - Field: 'calls'
[17:29:25.729]   - Field: 'globals'
[17:29:25.729]   - Field: 'stdout'
[17:29:25.730]   - Field: 'earlySignal'
[17:29:25.730]   - Field: 'lazy'
[17:29:25.730]   - Field: 'state'
[17:29:25.731] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:25.731] - Launch lazy future ...
[17:29:25.732] Packages needed by the future expression (n = 0): <none>
[17:29:25.732] Packages needed by future strategies (n = 0): <none>
[17:29:25.733] {
[17:29:25.733]     {
[17:29:25.733]         {
[17:29:25.733]             ...future.startTime <- base::Sys.time()
[17:29:25.733]             {
[17:29:25.733]                 {
[17:29:25.733]                   {
[17:29:25.733]                     {
[17:29:25.733]                       base::local({
[17:29:25.733]                         has_future <- base::requireNamespace("future", 
[17:29:25.733]                           quietly = TRUE)
[17:29:25.733]                         if (has_future) {
[17:29:25.733]                           ns <- base::getNamespace("future")
[17:29:25.733]                           version <- ns[[".package"]][["version"]]
[17:29:25.733]                           if (is.null(version)) 
[17:29:25.733]                             version <- utils::packageVersion("future")
[17:29:25.733]                         }
[17:29:25.733]                         else {
[17:29:25.733]                           version <- NULL
[17:29:25.733]                         }
[17:29:25.733]                         if (!has_future || version < "1.8.0") {
[17:29:25.733]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:25.733]                             "", base::R.version$version.string), 
[17:29:25.733]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:25.733]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:25.733]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:25.733]                               "release", "version")], collapse = " "), 
[17:29:25.733]                             hostname = base::Sys.info()[["nodename"]])
[17:29:25.733]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:25.733]                             info)
[17:29:25.733]                           info <- base::paste(info, collapse = "; ")
[17:29:25.733]                           if (!has_future) {
[17:29:25.733]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:25.733]                               info)
[17:29:25.733]                           }
[17:29:25.733]                           else {
[17:29:25.733]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:25.733]                               info, version)
[17:29:25.733]                           }
[17:29:25.733]                           base::stop(msg)
[17:29:25.733]                         }
[17:29:25.733]                       })
[17:29:25.733]                     }
[17:29:25.733]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:25.733]                     base::options(mc.cores = 1L)
[17:29:25.733]                   }
[17:29:25.733]                   ...future.strategy.old <- future::plan("list")
[17:29:25.733]                   options(future.plan = NULL)
[17:29:25.733]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:25.733]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:25.733]                 }
[17:29:25.733]                 ...future.workdir <- getwd()
[17:29:25.733]             }
[17:29:25.733]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:25.733]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:25.733]         }
[17:29:25.733]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:25.733]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:25.733]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:25.733]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:25.733]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:25.733]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:25.733]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:25.733]             base::names(...future.oldOptions))
[17:29:25.733]     }
[17:29:25.733]     if (FALSE) {
[17:29:25.733]     }
[17:29:25.733]     else {
[17:29:25.733]         if (TRUE) {
[17:29:25.733]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:25.733]                 open = "w")
[17:29:25.733]         }
[17:29:25.733]         else {
[17:29:25.733]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:25.733]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:25.733]         }
[17:29:25.733]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:25.733]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:25.733]             base::sink(type = "output", split = FALSE)
[17:29:25.733]             base::close(...future.stdout)
[17:29:25.733]         }, add = TRUE)
[17:29:25.733]     }
[17:29:25.733]     ...future.frame <- base::sys.nframe()
[17:29:25.733]     ...future.conditions <- base::list()
[17:29:25.733]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:25.733]     if (FALSE) {
[17:29:25.733]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:25.733]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:25.733]     }
[17:29:25.733]     ...future.result <- base::tryCatch({
[17:29:25.733]         base::withCallingHandlers({
[17:29:25.733]             ...future.value <- base::withVisible(base::local({
[17:29:25.733]                 ...future.makeSendCondition <- base::local({
[17:29:25.733]                   sendCondition <- NULL
[17:29:25.733]                   function(frame = 1L) {
[17:29:25.733]                     if (is.function(sendCondition)) 
[17:29:25.733]                       return(sendCondition)
[17:29:25.733]                     ns <- getNamespace("parallel")
[17:29:25.733]                     if (exists("sendData", mode = "function", 
[17:29:25.733]                       envir = ns)) {
[17:29:25.733]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:25.733]                         envir = ns)
[17:29:25.733]                       envir <- sys.frame(frame)
[17:29:25.733]                       master <- NULL
[17:29:25.733]                       while (!identical(envir, .GlobalEnv) && 
[17:29:25.733]                         !identical(envir, emptyenv())) {
[17:29:25.733]                         if (exists("master", mode = "list", envir = envir, 
[17:29:25.733]                           inherits = FALSE)) {
[17:29:25.733]                           master <- get("master", mode = "list", 
[17:29:25.733]                             envir = envir, inherits = FALSE)
[17:29:25.733]                           if (inherits(master, c("SOCKnode", 
[17:29:25.733]                             "SOCK0node"))) {
[17:29:25.733]                             sendCondition <<- function(cond) {
[17:29:25.733]                               data <- list(type = "VALUE", value = cond, 
[17:29:25.733]                                 success = TRUE)
[17:29:25.733]                               parallel_sendData(master, data)
[17:29:25.733]                             }
[17:29:25.733]                             return(sendCondition)
[17:29:25.733]                           }
[17:29:25.733]                         }
[17:29:25.733]                         frame <- frame + 1L
[17:29:25.733]                         envir <- sys.frame(frame)
[17:29:25.733]                       }
[17:29:25.733]                     }
[17:29:25.733]                     sendCondition <<- function(cond) NULL
[17:29:25.733]                   }
[17:29:25.733]                 })
[17:29:25.733]                 withCallingHandlers({
[17:29:25.733]                   {
[17:29:25.733]                     Sys.sleep(0.1)
[17:29:25.733]                     kk
[17:29:25.733]                   }
[17:29:25.733]                 }, immediateCondition = function(cond) {
[17:29:25.733]                   sendCondition <- ...future.makeSendCondition()
[17:29:25.733]                   sendCondition(cond)
[17:29:25.733]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:25.733]                   {
[17:29:25.733]                     inherits <- base::inherits
[17:29:25.733]                     invokeRestart <- base::invokeRestart
[17:29:25.733]                     is.null <- base::is.null
[17:29:25.733]                     muffled <- FALSE
[17:29:25.733]                     if (inherits(cond, "message")) {
[17:29:25.733]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:25.733]                       if (muffled) 
[17:29:25.733]                         invokeRestart("muffleMessage")
[17:29:25.733]                     }
[17:29:25.733]                     else if (inherits(cond, "warning")) {
[17:29:25.733]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:25.733]                       if (muffled) 
[17:29:25.733]                         invokeRestart("muffleWarning")
[17:29:25.733]                     }
[17:29:25.733]                     else if (inherits(cond, "condition")) {
[17:29:25.733]                       if (!is.null(pattern)) {
[17:29:25.733]                         computeRestarts <- base::computeRestarts
[17:29:25.733]                         grepl <- base::grepl
[17:29:25.733]                         restarts <- computeRestarts(cond)
[17:29:25.733]                         for (restart in restarts) {
[17:29:25.733]                           name <- restart$name
[17:29:25.733]                           if (is.null(name)) 
[17:29:25.733]                             next
[17:29:25.733]                           if (!grepl(pattern, name)) 
[17:29:25.733]                             next
[17:29:25.733]                           invokeRestart(restart)
[17:29:25.733]                           muffled <- TRUE
[17:29:25.733]                           break
[17:29:25.733]                         }
[17:29:25.733]                       }
[17:29:25.733]                     }
[17:29:25.733]                     invisible(muffled)
[17:29:25.733]                   }
[17:29:25.733]                   muffleCondition(cond)
[17:29:25.733]                 })
[17:29:25.733]             }))
[17:29:25.733]             future::FutureResult(value = ...future.value$value, 
[17:29:25.733]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:25.733]                   ...future.rng), globalenv = if (FALSE) 
[17:29:25.733]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:25.733]                     ...future.globalenv.names))
[17:29:25.733]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:25.733]         }, condition = base::local({
[17:29:25.733]             c <- base::c
[17:29:25.733]             inherits <- base::inherits
[17:29:25.733]             invokeRestart <- base::invokeRestart
[17:29:25.733]             length <- base::length
[17:29:25.733]             list <- base::list
[17:29:25.733]             seq.int <- base::seq.int
[17:29:25.733]             signalCondition <- base::signalCondition
[17:29:25.733]             sys.calls <- base::sys.calls
[17:29:25.733]             `[[` <- base::`[[`
[17:29:25.733]             `+` <- base::`+`
[17:29:25.733]             `<<-` <- base::`<<-`
[17:29:25.733]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:25.733]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:25.733]                   3L)]
[17:29:25.733]             }
[17:29:25.733]             function(cond) {
[17:29:25.733]                 is_error <- inherits(cond, "error")
[17:29:25.733]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:25.733]                   NULL)
[17:29:25.733]                 if (is_error) {
[17:29:25.733]                   sessionInformation <- function() {
[17:29:25.733]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:25.733]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:25.733]                       search = base::search(), system = base::Sys.info())
[17:29:25.733]                   }
[17:29:25.733]                   ...future.conditions[[length(...future.conditions) + 
[17:29:25.733]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:25.733]                     cond$call), session = sessionInformation(), 
[17:29:25.733]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:25.733]                   signalCondition(cond)
[17:29:25.733]                 }
[17:29:25.733]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:25.733]                 "immediateCondition"))) {
[17:29:25.733]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:25.733]                   ...future.conditions[[length(...future.conditions) + 
[17:29:25.733]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:25.733]                   if (TRUE && !signal) {
[17:29:25.733]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:25.733]                     {
[17:29:25.733]                       inherits <- base::inherits
[17:29:25.733]                       invokeRestart <- base::invokeRestart
[17:29:25.733]                       is.null <- base::is.null
[17:29:25.733]                       muffled <- FALSE
[17:29:25.733]                       if (inherits(cond, "message")) {
[17:29:25.733]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:25.733]                         if (muffled) 
[17:29:25.733]                           invokeRestart("muffleMessage")
[17:29:25.733]                       }
[17:29:25.733]                       else if (inherits(cond, "warning")) {
[17:29:25.733]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:25.733]                         if (muffled) 
[17:29:25.733]                           invokeRestart("muffleWarning")
[17:29:25.733]                       }
[17:29:25.733]                       else if (inherits(cond, "condition")) {
[17:29:25.733]                         if (!is.null(pattern)) {
[17:29:25.733]                           computeRestarts <- base::computeRestarts
[17:29:25.733]                           grepl <- base::grepl
[17:29:25.733]                           restarts <- computeRestarts(cond)
[17:29:25.733]                           for (restart in restarts) {
[17:29:25.733]                             name <- restart$name
[17:29:25.733]                             if (is.null(name)) 
[17:29:25.733]                               next
[17:29:25.733]                             if (!grepl(pattern, name)) 
[17:29:25.733]                               next
[17:29:25.733]                             invokeRestart(restart)
[17:29:25.733]                             muffled <- TRUE
[17:29:25.733]                             break
[17:29:25.733]                           }
[17:29:25.733]                         }
[17:29:25.733]                       }
[17:29:25.733]                       invisible(muffled)
[17:29:25.733]                     }
[17:29:25.733]                     muffleCondition(cond, pattern = "^muffle")
[17:29:25.733]                   }
[17:29:25.733]                 }
[17:29:25.733]                 else {
[17:29:25.733]                   if (TRUE) {
[17:29:25.733]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:25.733]                     {
[17:29:25.733]                       inherits <- base::inherits
[17:29:25.733]                       invokeRestart <- base::invokeRestart
[17:29:25.733]                       is.null <- base::is.null
[17:29:25.733]                       muffled <- FALSE
[17:29:25.733]                       if (inherits(cond, "message")) {
[17:29:25.733]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:25.733]                         if (muffled) 
[17:29:25.733]                           invokeRestart("muffleMessage")
[17:29:25.733]                       }
[17:29:25.733]                       else if (inherits(cond, "warning")) {
[17:29:25.733]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:25.733]                         if (muffled) 
[17:29:25.733]                           invokeRestart("muffleWarning")
[17:29:25.733]                       }
[17:29:25.733]                       else if (inherits(cond, "condition")) {
[17:29:25.733]                         if (!is.null(pattern)) {
[17:29:25.733]                           computeRestarts <- base::computeRestarts
[17:29:25.733]                           grepl <- base::grepl
[17:29:25.733]                           restarts <- computeRestarts(cond)
[17:29:25.733]                           for (restart in restarts) {
[17:29:25.733]                             name <- restart$name
[17:29:25.733]                             if (is.null(name)) 
[17:29:25.733]                               next
[17:29:25.733]                             if (!grepl(pattern, name)) 
[17:29:25.733]                               next
[17:29:25.733]                             invokeRestart(restart)
[17:29:25.733]                             muffled <- TRUE
[17:29:25.733]                             break
[17:29:25.733]                           }
[17:29:25.733]                         }
[17:29:25.733]                       }
[17:29:25.733]                       invisible(muffled)
[17:29:25.733]                     }
[17:29:25.733]                     muffleCondition(cond, pattern = "^muffle")
[17:29:25.733]                   }
[17:29:25.733]                 }
[17:29:25.733]             }
[17:29:25.733]         }))
[17:29:25.733]     }, error = function(ex) {
[17:29:25.733]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:25.733]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:25.733]                 ...future.rng), started = ...future.startTime, 
[17:29:25.733]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:25.733]             version = "1.8"), class = "FutureResult")
[17:29:25.733]     }, finally = {
[17:29:25.733]         if (!identical(...future.workdir, getwd())) 
[17:29:25.733]             setwd(...future.workdir)
[17:29:25.733]         {
[17:29:25.733]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:25.733]                 ...future.oldOptions$nwarnings <- NULL
[17:29:25.733]             }
[17:29:25.733]             base::options(...future.oldOptions)
[17:29:25.733]             if (.Platform$OS.type == "windows") {
[17:29:25.733]                 old_names <- names(...future.oldEnvVars)
[17:29:25.733]                 envs <- base::Sys.getenv()
[17:29:25.733]                 names <- names(envs)
[17:29:25.733]                 common <- intersect(names, old_names)
[17:29:25.733]                 added <- setdiff(names, old_names)
[17:29:25.733]                 removed <- setdiff(old_names, names)
[17:29:25.733]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:25.733]                   envs[common]]
[17:29:25.733]                 NAMES <- toupper(changed)
[17:29:25.733]                 args <- list()
[17:29:25.733]                 for (kk in seq_along(NAMES)) {
[17:29:25.733]                   name <- changed[[kk]]
[17:29:25.733]                   NAME <- NAMES[[kk]]
[17:29:25.733]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:25.733]                     next
[17:29:25.733]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:25.733]                 }
[17:29:25.733]                 NAMES <- toupper(added)
[17:29:25.733]                 for (kk in seq_along(NAMES)) {
[17:29:25.733]                   name <- added[[kk]]
[17:29:25.733]                   NAME <- NAMES[[kk]]
[17:29:25.733]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:25.733]                     next
[17:29:25.733]                   args[[name]] <- ""
[17:29:25.733]                 }
[17:29:25.733]                 NAMES <- toupper(removed)
[17:29:25.733]                 for (kk in seq_along(NAMES)) {
[17:29:25.733]                   name <- removed[[kk]]
[17:29:25.733]                   NAME <- NAMES[[kk]]
[17:29:25.733]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:25.733]                     next
[17:29:25.733]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:25.733]                 }
[17:29:25.733]                 if (length(args) > 0) 
[17:29:25.733]                   base::do.call(base::Sys.setenv, args = args)
[17:29:25.733]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:25.733]             }
[17:29:25.733]             else {
[17:29:25.733]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:25.733]             }
[17:29:25.733]             {
[17:29:25.733]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:25.733]                   0L) {
[17:29:25.733]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:25.733]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:25.733]                   base::options(opts)
[17:29:25.733]                 }
[17:29:25.733]                 {
[17:29:25.733]                   {
[17:29:25.733]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:25.733]                     NULL
[17:29:25.733]                   }
[17:29:25.733]                   options(future.plan = NULL)
[17:29:25.733]                   if (is.na(NA_character_)) 
[17:29:25.733]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:25.733]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:25.733]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:25.733]                     .init = FALSE)
[17:29:25.733]                 }
[17:29:25.733]             }
[17:29:25.733]         }
[17:29:25.733]     })
[17:29:25.733]     if (TRUE) {
[17:29:25.733]         base::sink(type = "output", split = FALSE)
[17:29:25.733]         if (TRUE) {
[17:29:25.733]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:25.733]         }
[17:29:25.733]         else {
[17:29:25.733]             ...future.result["stdout"] <- base::list(NULL)
[17:29:25.733]         }
[17:29:25.733]         base::close(...future.stdout)
[17:29:25.733]         ...future.stdout <- NULL
[17:29:25.733]     }
[17:29:25.733]     ...future.result$conditions <- ...future.conditions
[17:29:25.733]     ...future.result$finished <- base::Sys.time()
[17:29:25.733]     ...future.result
[17:29:25.733] }
[17:29:25.742] Exporting 1 global objects (340 bytes) to cluster node #1 ...
[17:29:25.743] Exporting 'kk' (35 bytes) to cluster node #1 ...
[17:29:25.743] Exporting 'kk' (35 bytes) to cluster node #1 ... DONE
[17:29:25.744] Exporting 1 global objects (340 bytes) to cluster node #1 ... DONE
[17:29:25.745] MultisessionFuture started
[17:29:25.745] - Launch lazy future ... done
[17:29:25.745] run() for 'MultisessionFuture' ... done
[17:29:25.870] receiveMessageFromWorker() for ClusterFuture ...
[17:29:25.871] - Validating connection of MultisessionFuture
[17:29:25.872] - received message: FutureResult
[17:29:25.872] - Received FutureResult
[17:29:25.872] - Erased future from FutureRegistry
[17:29:25.873] result() for ClusterFuture ...
[17:29:25.873] - result already collected: FutureResult
[17:29:25.873] result() for ClusterFuture ... done
[17:29:25.873] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:25.874] Future #3
[17:29:25.874]  length: 0 (resolved future 3)
[17:29:25.874] resolve() on list ... DONE
*** resolve() for lists ... DONE
*** resolve() for environments ...
[17:29:25.875] resolve() on environment ...
[17:29:25.876]  recursive: 0
[17:29:25.877]  elements: [2] 'a', 'b'
[17:29:25.877]  length: 1 (resolved future 1)
[17:29:25.877]  length: 0 (resolved future 2)
[17:29:25.878] resolve() on environment ... DONE
[17:29:25.878] getGlobalsAndPackages() ...
[17:29:25.879] Searching for globals...
[17:29:25.879] 
[17:29:25.879] Searching for globals ... DONE
[17:29:25.880] - globals: [0] <none>
[17:29:25.880] getGlobalsAndPackages() ... DONE
[17:29:25.880] run() for 'Future' ...
[17:29:25.880] - state: 'created'
[17:29:25.881] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:25.900] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:25.900] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:25.901]   - Field: 'node'
[17:29:25.901]   - Field: 'label'
[17:29:25.901]   - Field: 'local'
[17:29:25.901]   - Field: 'owner'
[17:29:25.901]   - Field: 'envir'
[17:29:25.902]   - Field: 'workers'
[17:29:25.902]   - Field: 'packages'
[17:29:25.902]   - Field: 'gc'
[17:29:25.902]   - Field: 'conditions'
[17:29:25.902]   - Field: 'persistent'
[17:29:25.902]   - Field: 'expr'
[17:29:25.903]   - Field: 'uuid'
[17:29:25.903]   - Field: 'seed'
[17:29:25.903]   - Field: 'version'
[17:29:25.903]   - Field: 'result'
[17:29:25.903]   - Field: 'asynchronous'
[17:29:25.903]   - Field: 'calls'
[17:29:25.904]   - Field: 'globals'
[17:29:25.904]   - Field: 'stdout'
[17:29:25.904]   - Field: 'earlySignal'
[17:29:25.904]   - Field: 'lazy'
[17:29:25.904]   - Field: 'state'
[17:29:25.905] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:25.905] - Launch lazy future ...
[17:29:25.905] Packages needed by the future expression (n = 0): <none>
[17:29:25.905] Packages needed by future strategies (n = 0): <none>
[17:29:25.906] {
[17:29:25.906]     {
[17:29:25.906]         {
[17:29:25.906]             ...future.startTime <- base::Sys.time()
[17:29:25.906]             {
[17:29:25.906]                 {
[17:29:25.906]                   {
[17:29:25.906]                     {
[17:29:25.906]                       base::local({
[17:29:25.906]                         has_future <- base::requireNamespace("future", 
[17:29:25.906]                           quietly = TRUE)
[17:29:25.906]                         if (has_future) {
[17:29:25.906]                           ns <- base::getNamespace("future")
[17:29:25.906]                           version <- ns[[".package"]][["version"]]
[17:29:25.906]                           if (is.null(version)) 
[17:29:25.906]                             version <- utils::packageVersion("future")
[17:29:25.906]                         }
[17:29:25.906]                         else {
[17:29:25.906]                           version <- NULL
[17:29:25.906]                         }
[17:29:25.906]                         if (!has_future || version < "1.8.0") {
[17:29:25.906]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:25.906]                             "", base::R.version$version.string), 
[17:29:25.906]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:25.906]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:25.906]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:25.906]                               "release", "version")], collapse = " "), 
[17:29:25.906]                             hostname = base::Sys.info()[["nodename"]])
[17:29:25.906]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:25.906]                             info)
[17:29:25.906]                           info <- base::paste(info, collapse = "; ")
[17:29:25.906]                           if (!has_future) {
[17:29:25.906]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:25.906]                               info)
[17:29:25.906]                           }
[17:29:25.906]                           else {
[17:29:25.906]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:25.906]                               info, version)
[17:29:25.906]                           }
[17:29:25.906]                           base::stop(msg)
[17:29:25.906]                         }
[17:29:25.906]                       })
[17:29:25.906]                     }
[17:29:25.906]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:25.906]                     base::options(mc.cores = 1L)
[17:29:25.906]                   }
[17:29:25.906]                   ...future.strategy.old <- future::plan("list")
[17:29:25.906]                   options(future.plan = NULL)
[17:29:25.906]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:25.906]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:25.906]                 }
[17:29:25.906]                 ...future.workdir <- getwd()
[17:29:25.906]             }
[17:29:25.906]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:25.906]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:25.906]         }
[17:29:25.906]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:25.906]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:25.906]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:25.906]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:25.906]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:25.906]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:25.906]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:25.906]             base::names(...future.oldOptions))
[17:29:25.906]     }
[17:29:25.906]     if (FALSE) {
[17:29:25.906]     }
[17:29:25.906]     else {
[17:29:25.906]         if (TRUE) {
[17:29:25.906]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:25.906]                 open = "w")
[17:29:25.906]         }
[17:29:25.906]         else {
[17:29:25.906]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:25.906]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:25.906]         }
[17:29:25.906]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:25.906]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:25.906]             base::sink(type = "output", split = FALSE)
[17:29:25.906]             base::close(...future.stdout)
[17:29:25.906]         }, add = TRUE)
[17:29:25.906]     }
[17:29:25.906]     ...future.frame <- base::sys.nframe()
[17:29:25.906]     ...future.conditions <- base::list()
[17:29:25.906]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:25.906]     if (FALSE) {
[17:29:25.906]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:25.906]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:25.906]     }
[17:29:25.906]     ...future.result <- base::tryCatch({
[17:29:25.906]         base::withCallingHandlers({
[17:29:25.906]             ...future.value <- base::withVisible(base::local({
[17:29:25.906]                 ...future.makeSendCondition <- base::local({
[17:29:25.906]                   sendCondition <- NULL
[17:29:25.906]                   function(frame = 1L) {
[17:29:25.906]                     if (is.function(sendCondition)) 
[17:29:25.906]                       return(sendCondition)
[17:29:25.906]                     ns <- getNamespace("parallel")
[17:29:25.906]                     if (exists("sendData", mode = "function", 
[17:29:25.906]                       envir = ns)) {
[17:29:25.906]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:25.906]                         envir = ns)
[17:29:25.906]                       envir <- sys.frame(frame)
[17:29:25.906]                       master <- NULL
[17:29:25.906]                       while (!identical(envir, .GlobalEnv) && 
[17:29:25.906]                         !identical(envir, emptyenv())) {
[17:29:25.906]                         if (exists("master", mode = "list", envir = envir, 
[17:29:25.906]                           inherits = FALSE)) {
[17:29:25.906]                           master <- get("master", mode = "list", 
[17:29:25.906]                             envir = envir, inherits = FALSE)
[17:29:25.906]                           if (inherits(master, c("SOCKnode", 
[17:29:25.906]                             "SOCK0node"))) {
[17:29:25.906]                             sendCondition <<- function(cond) {
[17:29:25.906]                               data <- list(type = "VALUE", value = cond, 
[17:29:25.906]                                 success = TRUE)
[17:29:25.906]                               parallel_sendData(master, data)
[17:29:25.906]                             }
[17:29:25.906]                             return(sendCondition)
[17:29:25.906]                           }
[17:29:25.906]                         }
[17:29:25.906]                         frame <- frame + 1L
[17:29:25.906]                         envir <- sys.frame(frame)
[17:29:25.906]                       }
[17:29:25.906]                     }
[17:29:25.906]                     sendCondition <<- function(cond) NULL
[17:29:25.906]                   }
[17:29:25.906]                 })
[17:29:25.906]                 withCallingHandlers({
[17:29:25.906]                   1
[17:29:25.906]                 }, immediateCondition = function(cond) {
[17:29:25.906]                   sendCondition <- ...future.makeSendCondition()
[17:29:25.906]                   sendCondition(cond)
[17:29:25.906]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:25.906]                   {
[17:29:25.906]                     inherits <- base::inherits
[17:29:25.906]                     invokeRestart <- base::invokeRestart
[17:29:25.906]                     is.null <- base::is.null
[17:29:25.906]                     muffled <- FALSE
[17:29:25.906]                     if (inherits(cond, "message")) {
[17:29:25.906]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:25.906]                       if (muffled) 
[17:29:25.906]                         invokeRestart("muffleMessage")
[17:29:25.906]                     }
[17:29:25.906]                     else if (inherits(cond, "warning")) {
[17:29:25.906]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:25.906]                       if (muffled) 
[17:29:25.906]                         invokeRestart("muffleWarning")
[17:29:25.906]                     }
[17:29:25.906]                     else if (inherits(cond, "condition")) {
[17:29:25.906]                       if (!is.null(pattern)) {
[17:29:25.906]                         computeRestarts <- base::computeRestarts
[17:29:25.906]                         grepl <- base::grepl
[17:29:25.906]                         restarts <- computeRestarts(cond)
[17:29:25.906]                         for (restart in restarts) {
[17:29:25.906]                           name <- restart$name
[17:29:25.906]                           if (is.null(name)) 
[17:29:25.906]                             next
[17:29:25.906]                           if (!grepl(pattern, name)) 
[17:29:25.906]                             next
[17:29:25.906]                           invokeRestart(restart)
[17:29:25.906]                           muffled <- TRUE
[17:29:25.906]                           break
[17:29:25.906]                         }
[17:29:25.906]                       }
[17:29:25.906]                     }
[17:29:25.906]                     invisible(muffled)
[17:29:25.906]                   }
[17:29:25.906]                   muffleCondition(cond)
[17:29:25.906]                 })
[17:29:25.906]             }))
[17:29:25.906]             future::FutureResult(value = ...future.value$value, 
[17:29:25.906]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:25.906]                   ...future.rng), globalenv = if (FALSE) 
[17:29:25.906]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:25.906]                     ...future.globalenv.names))
[17:29:25.906]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:25.906]         }, condition = base::local({
[17:29:25.906]             c <- base::c
[17:29:25.906]             inherits <- base::inherits
[17:29:25.906]             invokeRestart <- base::invokeRestart
[17:29:25.906]             length <- base::length
[17:29:25.906]             list <- base::list
[17:29:25.906]             seq.int <- base::seq.int
[17:29:25.906]             signalCondition <- base::signalCondition
[17:29:25.906]             sys.calls <- base::sys.calls
[17:29:25.906]             `[[` <- base::`[[`
[17:29:25.906]             `+` <- base::`+`
[17:29:25.906]             `<<-` <- base::`<<-`
[17:29:25.906]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:25.906]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:25.906]                   3L)]
[17:29:25.906]             }
[17:29:25.906]             function(cond) {
[17:29:25.906]                 is_error <- inherits(cond, "error")
[17:29:25.906]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:25.906]                   NULL)
[17:29:25.906]                 if (is_error) {
[17:29:25.906]                   sessionInformation <- function() {
[17:29:25.906]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:25.906]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:25.906]                       search = base::search(), system = base::Sys.info())
[17:29:25.906]                   }
[17:29:25.906]                   ...future.conditions[[length(...future.conditions) + 
[17:29:25.906]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:25.906]                     cond$call), session = sessionInformation(), 
[17:29:25.906]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:25.906]                   signalCondition(cond)
[17:29:25.906]                 }
[17:29:25.906]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:25.906]                 "immediateCondition"))) {
[17:29:25.906]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:25.906]                   ...future.conditions[[length(...future.conditions) + 
[17:29:25.906]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:25.906]                   if (TRUE && !signal) {
[17:29:25.906]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:25.906]                     {
[17:29:25.906]                       inherits <- base::inherits
[17:29:25.906]                       invokeRestart <- base::invokeRestart
[17:29:25.906]                       is.null <- base::is.null
[17:29:25.906]                       muffled <- FALSE
[17:29:25.906]                       if (inherits(cond, "message")) {
[17:29:25.906]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:25.906]                         if (muffled) 
[17:29:25.906]                           invokeRestart("muffleMessage")
[17:29:25.906]                       }
[17:29:25.906]                       else if (inherits(cond, "warning")) {
[17:29:25.906]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:25.906]                         if (muffled) 
[17:29:25.906]                           invokeRestart("muffleWarning")
[17:29:25.906]                       }
[17:29:25.906]                       else if (inherits(cond, "condition")) {
[17:29:25.906]                         if (!is.null(pattern)) {
[17:29:25.906]                           computeRestarts <- base::computeRestarts
[17:29:25.906]                           grepl <- base::grepl
[17:29:25.906]                           restarts <- computeRestarts(cond)
[17:29:25.906]                           for (restart in restarts) {
[17:29:25.906]                             name <- restart$name
[17:29:25.906]                             if (is.null(name)) 
[17:29:25.906]                               next
[17:29:25.906]                             if (!grepl(pattern, name)) 
[17:29:25.906]                               next
[17:29:25.906]                             invokeRestart(restart)
[17:29:25.906]                             muffled <- TRUE
[17:29:25.906]                             break
[17:29:25.906]                           }
[17:29:25.906]                         }
[17:29:25.906]                       }
[17:29:25.906]                       invisible(muffled)
[17:29:25.906]                     }
[17:29:25.906]                     muffleCondition(cond, pattern = "^muffle")
[17:29:25.906]                   }
[17:29:25.906]                 }
[17:29:25.906]                 else {
[17:29:25.906]                   if (TRUE) {
[17:29:25.906]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:25.906]                     {
[17:29:25.906]                       inherits <- base::inherits
[17:29:25.906]                       invokeRestart <- base::invokeRestart
[17:29:25.906]                       is.null <- base::is.null
[17:29:25.906]                       muffled <- FALSE
[17:29:25.906]                       if (inherits(cond, "message")) {
[17:29:25.906]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:25.906]                         if (muffled) 
[17:29:25.906]                           invokeRestart("muffleMessage")
[17:29:25.906]                       }
[17:29:25.906]                       else if (inherits(cond, "warning")) {
[17:29:25.906]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:25.906]                         if (muffled) 
[17:29:25.906]                           invokeRestart("muffleWarning")
[17:29:25.906]                       }
[17:29:25.906]                       else if (inherits(cond, "condition")) {
[17:29:25.906]                         if (!is.null(pattern)) {
[17:29:25.906]                           computeRestarts <- base::computeRestarts
[17:29:25.906]                           grepl <- base::grepl
[17:29:25.906]                           restarts <- computeRestarts(cond)
[17:29:25.906]                           for (restart in restarts) {
[17:29:25.906]                             name <- restart$name
[17:29:25.906]                             if (is.null(name)) 
[17:29:25.906]                               next
[17:29:25.906]                             if (!grepl(pattern, name)) 
[17:29:25.906]                               next
[17:29:25.906]                             invokeRestart(restart)
[17:29:25.906]                             muffled <- TRUE
[17:29:25.906]                             break
[17:29:25.906]                           }
[17:29:25.906]                         }
[17:29:25.906]                       }
[17:29:25.906]                       invisible(muffled)
[17:29:25.906]                     }
[17:29:25.906]                     muffleCondition(cond, pattern = "^muffle")
[17:29:25.906]                   }
[17:29:25.906]                 }
[17:29:25.906]             }
[17:29:25.906]         }))
[17:29:25.906]     }, error = function(ex) {
[17:29:25.906]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:25.906]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:25.906]                 ...future.rng), started = ...future.startTime, 
[17:29:25.906]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:25.906]             version = "1.8"), class = "FutureResult")
[17:29:25.906]     }, finally = {
[17:29:25.906]         if (!identical(...future.workdir, getwd())) 
[17:29:25.906]             setwd(...future.workdir)
[17:29:25.906]         {
[17:29:25.906]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:25.906]                 ...future.oldOptions$nwarnings <- NULL
[17:29:25.906]             }
[17:29:25.906]             base::options(...future.oldOptions)
[17:29:25.906]             if (.Platform$OS.type == "windows") {
[17:29:25.906]                 old_names <- names(...future.oldEnvVars)
[17:29:25.906]                 envs <- base::Sys.getenv()
[17:29:25.906]                 names <- names(envs)
[17:29:25.906]                 common <- intersect(names, old_names)
[17:29:25.906]                 added <- setdiff(names, old_names)
[17:29:25.906]                 removed <- setdiff(old_names, names)
[17:29:25.906]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:25.906]                   envs[common]]
[17:29:25.906]                 NAMES <- toupper(changed)
[17:29:25.906]                 args <- list()
[17:29:25.906]                 for (kk in seq_along(NAMES)) {
[17:29:25.906]                   name <- changed[[kk]]
[17:29:25.906]                   NAME <- NAMES[[kk]]
[17:29:25.906]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:25.906]                     next
[17:29:25.906]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:25.906]                 }
[17:29:25.906]                 NAMES <- toupper(added)
[17:29:25.906]                 for (kk in seq_along(NAMES)) {
[17:29:25.906]                   name <- added[[kk]]
[17:29:25.906]                   NAME <- NAMES[[kk]]
[17:29:25.906]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:25.906]                     next
[17:29:25.906]                   args[[name]] <- ""
[17:29:25.906]                 }
[17:29:25.906]                 NAMES <- toupper(removed)
[17:29:25.906]                 for (kk in seq_along(NAMES)) {
[17:29:25.906]                   name <- removed[[kk]]
[17:29:25.906]                   NAME <- NAMES[[kk]]
[17:29:25.906]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:25.906]                     next
[17:29:25.906]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:25.906]                 }
[17:29:25.906]                 if (length(args) > 0) 
[17:29:25.906]                   base::do.call(base::Sys.setenv, args = args)
[17:29:25.906]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:25.906]             }
[17:29:25.906]             else {
[17:29:25.906]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:25.906]             }
[17:29:25.906]             {
[17:29:25.906]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:25.906]                   0L) {
[17:29:25.906]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:25.906]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:25.906]                   base::options(opts)
[17:29:25.906]                 }
[17:29:25.906]                 {
[17:29:25.906]                   {
[17:29:25.906]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:25.906]                     NULL
[17:29:25.906]                   }
[17:29:25.906]                   options(future.plan = NULL)
[17:29:25.906]                   if (is.na(NA_character_)) 
[17:29:25.906]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:25.906]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:25.906]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:25.906]                     .init = FALSE)
[17:29:25.906]                 }
[17:29:25.906]             }
[17:29:25.906]         }
[17:29:25.906]     })
[17:29:25.906]     if (TRUE) {
[17:29:25.906]         base::sink(type = "output", split = FALSE)
[17:29:25.906]         if (TRUE) {
[17:29:25.906]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:25.906]         }
[17:29:25.906]         else {
[17:29:25.906]             ...future.result["stdout"] <- base::list(NULL)
[17:29:25.906]         }
[17:29:25.906]         base::close(...future.stdout)
[17:29:25.906]         ...future.stdout <- NULL
[17:29:25.906]     }
[17:29:25.906]     ...future.result$conditions <- ...future.conditions
[17:29:25.906]     ...future.result$finished <- base::Sys.time()
[17:29:25.906]     ...future.result
[17:29:25.906] }
[17:29:25.913] MultisessionFuture started
[17:29:25.913] - Launch lazy future ... done
[17:29:25.914] run() for 'MultisessionFuture' ... done
[17:29:25.914] getGlobalsAndPackages() ...
[17:29:25.914] Searching for globals...
[17:29:25.915] 
[17:29:25.915] Searching for globals ... DONE
[17:29:25.916] - globals: [0] <none>
[17:29:25.916] getGlobalsAndPackages() ... DONE
[17:29:25.916] run() for 'Future' ...
[17:29:25.917] - state: 'created'
[17:29:25.917] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:25.937] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:25.937] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:25.937]   - Field: 'node'
[17:29:25.937]   - Field: 'label'
[17:29:25.937]   - Field: 'local'
[17:29:25.938]   - Field: 'owner'
[17:29:25.938]   - Field: 'envir'
[17:29:25.938]   - Field: 'workers'
[17:29:25.938]   - Field: 'packages'
[17:29:25.938]   - Field: 'gc'
[17:29:25.939]   - Field: 'conditions'
[17:29:25.939]   - Field: 'persistent'
[17:29:25.939]   - Field: 'expr'
[17:29:25.939]   - Field: 'uuid'
[17:29:25.939]   - Field: 'seed'
[17:29:25.939]   - Field: 'version'
[17:29:25.940]   - Field: 'result'
[17:29:25.940]   - Field: 'asynchronous'
[17:29:25.940]   - Field: 'calls'
[17:29:25.940]   - Field: 'globals'
[17:29:25.940]   - Field: 'stdout'
[17:29:25.941]   - Field: 'earlySignal'
[17:29:25.941]   - Field: 'lazy'
[17:29:25.941]   - Field: 'state'
[17:29:25.942] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:25.942] - Launch lazy future ...
[17:29:25.943] Packages needed by the future expression (n = 0): <none>
[17:29:25.943] Packages needed by future strategies (n = 0): <none>
[17:29:25.944] {
[17:29:25.944]     {
[17:29:25.944]         {
[17:29:25.944]             ...future.startTime <- base::Sys.time()
[17:29:25.944]             {
[17:29:25.944]                 {
[17:29:25.944]                   {
[17:29:25.944]                     {
[17:29:25.944]                       base::local({
[17:29:25.944]                         has_future <- base::requireNamespace("future", 
[17:29:25.944]                           quietly = TRUE)
[17:29:25.944]                         if (has_future) {
[17:29:25.944]                           ns <- base::getNamespace("future")
[17:29:25.944]                           version <- ns[[".package"]][["version"]]
[17:29:25.944]                           if (is.null(version)) 
[17:29:25.944]                             version <- utils::packageVersion("future")
[17:29:25.944]                         }
[17:29:25.944]                         else {
[17:29:25.944]                           version <- NULL
[17:29:25.944]                         }
[17:29:25.944]                         if (!has_future || version < "1.8.0") {
[17:29:25.944]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:25.944]                             "", base::R.version$version.string), 
[17:29:25.944]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:25.944]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:25.944]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:25.944]                               "release", "version")], collapse = " "), 
[17:29:25.944]                             hostname = base::Sys.info()[["nodename"]])
[17:29:25.944]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:25.944]                             info)
[17:29:25.944]                           info <- base::paste(info, collapse = "; ")
[17:29:25.944]                           if (!has_future) {
[17:29:25.944]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:25.944]                               info)
[17:29:25.944]                           }
[17:29:25.944]                           else {
[17:29:25.944]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:25.944]                               info, version)
[17:29:25.944]                           }
[17:29:25.944]                           base::stop(msg)
[17:29:25.944]                         }
[17:29:25.944]                       })
[17:29:25.944]                     }
[17:29:25.944]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:25.944]                     base::options(mc.cores = 1L)
[17:29:25.944]                   }
[17:29:25.944]                   ...future.strategy.old <- future::plan("list")
[17:29:25.944]                   options(future.plan = NULL)
[17:29:25.944]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:25.944]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:25.944]                 }
[17:29:25.944]                 ...future.workdir <- getwd()
[17:29:25.944]             }
[17:29:25.944]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:25.944]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:25.944]         }
[17:29:25.944]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:25.944]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:25.944]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:25.944]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:25.944]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:25.944]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:25.944]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:25.944]             base::names(...future.oldOptions))
[17:29:25.944]     }
[17:29:25.944]     if (FALSE) {
[17:29:25.944]     }
[17:29:25.944]     else {
[17:29:25.944]         if (TRUE) {
[17:29:25.944]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:25.944]                 open = "w")
[17:29:25.944]         }
[17:29:25.944]         else {
[17:29:25.944]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:25.944]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:25.944]         }
[17:29:25.944]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:25.944]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:25.944]             base::sink(type = "output", split = FALSE)
[17:29:25.944]             base::close(...future.stdout)
[17:29:25.944]         }, add = TRUE)
[17:29:25.944]     }
[17:29:25.944]     ...future.frame <- base::sys.nframe()
[17:29:25.944]     ...future.conditions <- base::list()
[17:29:25.944]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:25.944]     if (FALSE) {
[17:29:25.944]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:25.944]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:25.944]     }
[17:29:25.944]     ...future.result <- base::tryCatch({
[17:29:25.944]         base::withCallingHandlers({
[17:29:25.944]             ...future.value <- base::withVisible(base::local({
[17:29:25.944]                 ...future.makeSendCondition <- base::local({
[17:29:25.944]                   sendCondition <- NULL
[17:29:25.944]                   function(frame = 1L) {
[17:29:25.944]                     if (is.function(sendCondition)) 
[17:29:25.944]                       return(sendCondition)
[17:29:25.944]                     ns <- getNamespace("parallel")
[17:29:25.944]                     if (exists("sendData", mode = "function", 
[17:29:25.944]                       envir = ns)) {
[17:29:25.944]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:25.944]                         envir = ns)
[17:29:25.944]                       envir <- sys.frame(frame)
[17:29:25.944]                       master <- NULL
[17:29:25.944]                       while (!identical(envir, .GlobalEnv) && 
[17:29:25.944]                         !identical(envir, emptyenv())) {
[17:29:25.944]                         if (exists("master", mode = "list", envir = envir, 
[17:29:25.944]                           inherits = FALSE)) {
[17:29:25.944]                           master <- get("master", mode = "list", 
[17:29:25.944]                             envir = envir, inherits = FALSE)
[17:29:25.944]                           if (inherits(master, c("SOCKnode", 
[17:29:25.944]                             "SOCK0node"))) {
[17:29:25.944]                             sendCondition <<- function(cond) {
[17:29:25.944]                               data <- list(type = "VALUE", value = cond, 
[17:29:25.944]                                 success = TRUE)
[17:29:25.944]                               parallel_sendData(master, data)
[17:29:25.944]                             }
[17:29:25.944]                             return(sendCondition)
[17:29:25.944]                           }
[17:29:25.944]                         }
[17:29:25.944]                         frame <- frame + 1L
[17:29:25.944]                         envir <- sys.frame(frame)
[17:29:25.944]                       }
[17:29:25.944]                     }
[17:29:25.944]                     sendCondition <<- function(cond) NULL
[17:29:25.944]                   }
[17:29:25.944]                 })
[17:29:25.944]                 withCallingHandlers({
[17:29:25.944]                   2
[17:29:25.944]                 }, immediateCondition = function(cond) {
[17:29:25.944]                   sendCondition <- ...future.makeSendCondition()
[17:29:25.944]                   sendCondition(cond)
[17:29:25.944]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:25.944]                   {
[17:29:25.944]                     inherits <- base::inherits
[17:29:25.944]                     invokeRestart <- base::invokeRestart
[17:29:25.944]                     is.null <- base::is.null
[17:29:25.944]                     muffled <- FALSE
[17:29:25.944]                     if (inherits(cond, "message")) {
[17:29:25.944]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:25.944]                       if (muffled) 
[17:29:25.944]                         invokeRestart("muffleMessage")
[17:29:25.944]                     }
[17:29:25.944]                     else if (inherits(cond, "warning")) {
[17:29:25.944]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:25.944]                       if (muffled) 
[17:29:25.944]                         invokeRestart("muffleWarning")
[17:29:25.944]                     }
[17:29:25.944]                     else if (inherits(cond, "condition")) {
[17:29:25.944]                       if (!is.null(pattern)) {
[17:29:25.944]                         computeRestarts <- base::computeRestarts
[17:29:25.944]                         grepl <- base::grepl
[17:29:25.944]                         restarts <- computeRestarts(cond)
[17:29:25.944]                         for (restart in restarts) {
[17:29:25.944]                           name <- restart$name
[17:29:25.944]                           if (is.null(name)) 
[17:29:25.944]                             next
[17:29:25.944]                           if (!grepl(pattern, name)) 
[17:29:25.944]                             next
[17:29:25.944]                           invokeRestart(restart)
[17:29:25.944]                           muffled <- TRUE
[17:29:25.944]                           break
[17:29:25.944]                         }
[17:29:25.944]                       }
[17:29:25.944]                     }
[17:29:25.944]                     invisible(muffled)
[17:29:25.944]                   }
[17:29:25.944]                   muffleCondition(cond)
[17:29:25.944]                 })
[17:29:25.944]             }))
[17:29:25.944]             future::FutureResult(value = ...future.value$value, 
[17:29:25.944]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:25.944]                   ...future.rng), globalenv = if (FALSE) 
[17:29:25.944]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:25.944]                     ...future.globalenv.names))
[17:29:25.944]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:25.944]         }, condition = base::local({
[17:29:25.944]             c <- base::c
[17:29:25.944]             inherits <- base::inherits
[17:29:25.944]             invokeRestart <- base::invokeRestart
[17:29:25.944]             length <- base::length
[17:29:25.944]             list <- base::list
[17:29:25.944]             seq.int <- base::seq.int
[17:29:25.944]             signalCondition <- base::signalCondition
[17:29:25.944]             sys.calls <- base::sys.calls
[17:29:25.944]             `[[` <- base::`[[`
[17:29:25.944]             `+` <- base::`+`
[17:29:25.944]             `<<-` <- base::`<<-`
[17:29:25.944]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:25.944]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:25.944]                   3L)]
[17:29:25.944]             }
[17:29:25.944]             function(cond) {
[17:29:25.944]                 is_error <- inherits(cond, "error")
[17:29:25.944]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:25.944]                   NULL)
[17:29:25.944]                 if (is_error) {
[17:29:25.944]                   sessionInformation <- function() {
[17:29:25.944]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:25.944]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:25.944]                       search = base::search(), system = base::Sys.info())
[17:29:25.944]                   }
[17:29:25.944]                   ...future.conditions[[length(...future.conditions) + 
[17:29:25.944]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:25.944]                     cond$call), session = sessionInformation(), 
[17:29:25.944]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:25.944]                   signalCondition(cond)
[17:29:25.944]                 }
[17:29:25.944]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:25.944]                 "immediateCondition"))) {
[17:29:25.944]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:25.944]                   ...future.conditions[[length(...future.conditions) + 
[17:29:25.944]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:25.944]                   if (TRUE && !signal) {
[17:29:25.944]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:25.944]                     {
[17:29:25.944]                       inherits <- base::inherits
[17:29:25.944]                       invokeRestart <- base::invokeRestart
[17:29:25.944]                       is.null <- base::is.null
[17:29:25.944]                       muffled <- FALSE
[17:29:25.944]                       if (inherits(cond, "message")) {
[17:29:25.944]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:25.944]                         if (muffled) 
[17:29:25.944]                           invokeRestart("muffleMessage")
[17:29:25.944]                       }
[17:29:25.944]                       else if (inherits(cond, "warning")) {
[17:29:25.944]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:25.944]                         if (muffled) 
[17:29:25.944]                           invokeRestart("muffleWarning")
[17:29:25.944]                       }
[17:29:25.944]                       else if (inherits(cond, "condition")) {
[17:29:25.944]                         if (!is.null(pattern)) {
[17:29:25.944]                           computeRestarts <- base::computeRestarts
[17:29:25.944]                           grepl <- base::grepl
[17:29:25.944]                           restarts <- computeRestarts(cond)
[17:29:25.944]                           for (restart in restarts) {
[17:29:25.944]                             name <- restart$name
[17:29:25.944]                             if (is.null(name)) 
[17:29:25.944]                               next
[17:29:25.944]                             if (!grepl(pattern, name)) 
[17:29:25.944]                               next
[17:29:25.944]                             invokeRestart(restart)
[17:29:25.944]                             muffled <- TRUE
[17:29:25.944]                             break
[17:29:25.944]                           }
[17:29:25.944]                         }
[17:29:25.944]                       }
[17:29:25.944]                       invisible(muffled)
[17:29:25.944]                     }
[17:29:25.944]                     muffleCondition(cond, pattern = "^muffle")
[17:29:25.944]                   }
[17:29:25.944]                 }
[17:29:25.944]                 else {
[17:29:25.944]                   if (TRUE) {
[17:29:25.944]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:25.944]                     {
[17:29:25.944]                       inherits <- base::inherits
[17:29:25.944]                       invokeRestart <- base::invokeRestart
[17:29:25.944]                       is.null <- base::is.null
[17:29:25.944]                       muffled <- FALSE
[17:29:25.944]                       if (inherits(cond, "message")) {
[17:29:25.944]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:25.944]                         if (muffled) 
[17:29:25.944]                           invokeRestart("muffleMessage")
[17:29:25.944]                       }
[17:29:25.944]                       else if (inherits(cond, "warning")) {
[17:29:25.944]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:25.944]                         if (muffled) 
[17:29:25.944]                           invokeRestart("muffleWarning")
[17:29:25.944]                       }
[17:29:25.944]                       else if (inherits(cond, "condition")) {
[17:29:25.944]                         if (!is.null(pattern)) {
[17:29:25.944]                           computeRestarts <- base::computeRestarts
[17:29:25.944]                           grepl <- base::grepl
[17:29:25.944]                           restarts <- computeRestarts(cond)
[17:29:25.944]                           for (restart in restarts) {
[17:29:25.944]                             name <- restart$name
[17:29:25.944]                             if (is.null(name)) 
[17:29:25.944]                               next
[17:29:25.944]                             if (!grepl(pattern, name)) 
[17:29:25.944]                               next
[17:29:25.944]                             invokeRestart(restart)
[17:29:25.944]                             muffled <- TRUE
[17:29:25.944]                             break
[17:29:25.944]                           }
[17:29:25.944]                         }
[17:29:25.944]                       }
[17:29:25.944]                       invisible(muffled)
[17:29:25.944]                     }
[17:29:25.944]                     muffleCondition(cond, pattern = "^muffle")
[17:29:25.944]                   }
[17:29:25.944]                 }
[17:29:25.944]             }
[17:29:25.944]         }))
[17:29:25.944]     }, error = function(ex) {
[17:29:25.944]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:25.944]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:25.944]                 ...future.rng), started = ...future.startTime, 
[17:29:25.944]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:25.944]             version = "1.8"), class = "FutureResult")
[17:29:25.944]     }, finally = {
[17:29:25.944]         if (!identical(...future.workdir, getwd())) 
[17:29:25.944]             setwd(...future.workdir)
[17:29:25.944]         {
[17:29:25.944]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:25.944]                 ...future.oldOptions$nwarnings <- NULL
[17:29:25.944]             }
[17:29:25.944]             base::options(...future.oldOptions)
[17:29:25.944]             if (.Platform$OS.type == "windows") {
[17:29:25.944]                 old_names <- names(...future.oldEnvVars)
[17:29:25.944]                 envs <- base::Sys.getenv()
[17:29:25.944]                 names <- names(envs)
[17:29:25.944]                 common <- intersect(names, old_names)
[17:29:25.944]                 added <- setdiff(names, old_names)
[17:29:25.944]                 removed <- setdiff(old_names, names)
[17:29:25.944]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:25.944]                   envs[common]]
[17:29:25.944]                 NAMES <- toupper(changed)
[17:29:25.944]                 args <- list()
[17:29:25.944]                 for (kk in seq_along(NAMES)) {
[17:29:25.944]                   name <- changed[[kk]]
[17:29:25.944]                   NAME <- NAMES[[kk]]
[17:29:25.944]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:25.944]                     next
[17:29:25.944]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:25.944]                 }
[17:29:25.944]                 NAMES <- toupper(added)
[17:29:25.944]                 for (kk in seq_along(NAMES)) {
[17:29:25.944]                   name <- added[[kk]]
[17:29:25.944]                   NAME <- NAMES[[kk]]
[17:29:25.944]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:25.944]                     next
[17:29:25.944]                   args[[name]] <- ""
[17:29:25.944]                 }
[17:29:25.944]                 NAMES <- toupper(removed)
[17:29:25.944]                 for (kk in seq_along(NAMES)) {
[17:29:25.944]                   name <- removed[[kk]]
[17:29:25.944]                   NAME <- NAMES[[kk]]
[17:29:25.944]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:25.944]                     next
[17:29:25.944]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:25.944]                 }
[17:29:25.944]                 if (length(args) > 0) 
[17:29:25.944]                   base::do.call(base::Sys.setenv, args = args)
[17:29:25.944]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:25.944]             }
[17:29:25.944]             else {
[17:29:25.944]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:25.944]             }
[17:29:25.944]             {
[17:29:25.944]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:25.944]                   0L) {
[17:29:25.944]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:25.944]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:25.944]                   base::options(opts)
[17:29:25.944]                 }
[17:29:25.944]                 {
[17:29:25.944]                   {
[17:29:25.944]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:25.944]                     NULL
[17:29:25.944]                   }
[17:29:25.944]                   options(future.plan = NULL)
[17:29:25.944]                   if (is.na(NA_character_)) 
[17:29:25.944]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:25.944]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:25.944]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:25.944]                     .init = FALSE)
[17:29:25.944]                 }
[17:29:25.944]             }
[17:29:25.944]         }
[17:29:25.944]     })
[17:29:25.944]     if (TRUE) {
[17:29:25.944]         base::sink(type = "output", split = FALSE)
[17:29:25.944]         if (TRUE) {
[17:29:25.944]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:25.944]         }
[17:29:25.944]         else {
[17:29:25.944]             ...future.result["stdout"] <- base::list(NULL)
[17:29:25.944]         }
[17:29:25.944]         base::close(...future.stdout)
[17:29:25.944]         ...future.stdout <- NULL
[17:29:25.944]     }
[17:29:25.944]     ...future.result$conditions <- ...future.conditions
[17:29:25.944]     ...future.result$finished <- base::Sys.time()
[17:29:25.944]     ...future.result
[17:29:25.944] }
[17:29:25.954] MultisessionFuture started
[17:29:25.954] - Launch lazy future ... done
[17:29:25.954] run() for 'MultisessionFuture' ... done
[17:29:25.955] resolve() on environment ...
[17:29:25.956]  recursive: 0
[17:29:25.957]  elements: [3] 'a', 'b', 'c'
[17:29:25.958] receiveMessageFromWorker() for ClusterFuture ...
[17:29:25.958] - Validating connection of MultisessionFuture
[17:29:25.958] - received message: FutureResult
[17:29:25.959] - Received FutureResult
[17:29:25.959] - Erased future from FutureRegistry
[17:29:25.959] result() for ClusterFuture ...
[17:29:25.960] - result already collected: FutureResult
[17:29:25.960] result() for ClusterFuture ... done
[17:29:25.960] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:25.960] Future #1
[17:29:25.961]  length: 2 (resolved future 1)
[17:29:25.981] receiveMessageFromWorker() for ClusterFuture ...
[17:29:25.981] - Validating connection of MultisessionFuture
[17:29:25.982] - received message: FutureResult
[17:29:25.982] - Received FutureResult
[17:29:25.982] - Erased future from FutureRegistry
[17:29:25.983] result() for ClusterFuture ...
[17:29:25.983] - result already collected: FutureResult
[17:29:25.983] result() for ClusterFuture ... done
[17:29:25.984] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:25.984] Future #2
[17:29:25.984]  length: 1 (resolved future 2)
[17:29:25.984]  length: 0 (resolved future 3)
[17:29:25.985] resolve() on environment ... DONE
[17:29:25.986] getGlobalsAndPackages() ...
[17:29:25.986] Searching for globals...
[17:29:25.988] - globals found: [1] '{'
[17:29:25.988] Searching for globals ... DONE
[17:29:25.988] Resolving globals: FALSE
[17:29:25.989] 
[17:29:25.989] 
[17:29:25.990] getGlobalsAndPackages() ... DONE
[17:29:25.990] run() for 'Future' ...
[17:29:25.991] - state: 'created'
[17:29:25.991] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:26.011] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:26.011] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:26.012]   - Field: 'node'
[17:29:26.012]   - Field: 'label'
[17:29:26.012]   - Field: 'local'
[17:29:26.013]   - Field: 'owner'
[17:29:26.013]   - Field: 'envir'
[17:29:26.013]   - Field: 'workers'
[17:29:26.013]   - Field: 'packages'
[17:29:26.014]   - Field: 'gc'
[17:29:26.014]   - Field: 'conditions'
[17:29:26.014]   - Field: 'persistent'
[17:29:26.014]   - Field: 'expr'
[17:29:26.015]   - Field: 'uuid'
[17:29:26.015]   - Field: 'seed'
[17:29:26.015]   - Field: 'version'
[17:29:26.015]   - Field: 'result'
[17:29:26.015]   - Field: 'asynchronous'
[17:29:26.016]   - Field: 'calls'
[17:29:26.016]   - Field: 'globals'
[17:29:26.016]   - Field: 'stdout'
[17:29:26.016]   - Field: 'earlySignal'
[17:29:26.017]   - Field: 'lazy'
[17:29:26.017]   - Field: 'state'
[17:29:26.017] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:26.018] - Launch lazy future ...
[17:29:26.018] Packages needed by the future expression (n = 0): <none>
[17:29:26.019] Packages needed by future strategies (n = 0): <none>
[17:29:26.020] {
[17:29:26.020]     {
[17:29:26.020]         {
[17:29:26.020]             ...future.startTime <- base::Sys.time()
[17:29:26.020]             {
[17:29:26.020]                 {
[17:29:26.020]                   {
[17:29:26.020]                     {
[17:29:26.020]                       base::local({
[17:29:26.020]                         has_future <- base::requireNamespace("future", 
[17:29:26.020]                           quietly = TRUE)
[17:29:26.020]                         if (has_future) {
[17:29:26.020]                           ns <- base::getNamespace("future")
[17:29:26.020]                           version <- ns[[".package"]][["version"]]
[17:29:26.020]                           if (is.null(version)) 
[17:29:26.020]                             version <- utils::packageVersion("future")
[17:29:26.020]                         }
[17:29:26.020]                         else {
[17:29:26.020]                           version <- NULL
[17:29:26.020]                         }
[17:29:26.020]                         if (!has_future || version < "1.8.0") {
[17:29:26.020]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:26.020]                             "", base::R.version$version.string), 
[17:29:26.020]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:26.020]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:26.020]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:26.020]                               "release", "version")], collapse = " "), 
[17:29:26.020]                             hostname = base::Sys.info()[["nodename"]])
[17:29:26.020]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:26.020]                             info)
[17:29:26.020]                           info <- base::paste(info, collapse = "; ")
[17:29:26.020]                           if (!has_future) {
[17:29:26.020]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:26.020]                               info)
[17:29:26.020]                           }
[17:29:26.020]                           else {
[17:29:26.020]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:26.020]                               info, version)
[17:29:26.020]                           }
[17:29:26.020]                           base::stop(msg)
[17:29:26.020]                         }
[17:29:26.020]                       })
[17:29:26.020]                     }
[17:29:26.020]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:26.020]                     base::options(mc.cores = 1L)
[17:29:26.020]                   }
[17:29:26.020]                   ...future.strategy.old <- future::plan("list")
[17:29:26.020]                   options(future.plan = NULL)
[17:29:26.020]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:26.020]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:26.020]                 }
[17:29:26.020]                 ...future.workdir <- getwd()
[17:29:26.020]             }
[17:29:26.020]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:26.020]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:26.020]         }
[17:29:26.020]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:26.020]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:26.020]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:26.020]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:26.020]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:26.020]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:26.020]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:26.020]             base::names(...future.oldOptions))
[17:29:26.020]     }
[17:29:26.020]     if (FALSE) {
[17:29:26.020]     }
[17:29:26.020]     else {
[17:29:26.020]         if (TRUE) {
[17:29:26.020]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:26.020]                 open = "w")
[17:29:26.020]         }
[17:29:26.020]         else {
[17:29:26.020]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:26.020]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:26.020]         }
[17:29:26.020]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:26.020]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:26.020]             base::sink(type = "output", split = FALSE)
[17:29:26.020]             base::close(...future.stdout)
[17:29:26.020]         }, add = TRUE)
[17:29:26.020]     }
[17:29:26.020]     ...future.frame <- base::sys.nframe()
[17:29:26.020]     ...future.conditions <- base::list()
[17:29:26.020]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:26.020]     if (FALSE) {
[17:29:26.020]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:26.020]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:26.020]     }
[17:29:26.020]     ...future.result <- base::tryCatch({
[17:29:26.020]         base::withCallingHandlers({
[17:29:26.020]             ...future.value <- base::withVisible(base::local({
[17:29:26.020]                 ...future.makeSendCondition <- base::local({
[17:29:26.020]                   sendCondition <- NULL
[17:29:26.020]                   function(frame = 1L) {
[17:29:26.020]                     if (is.function(sendCondition)) 
[17:29:26.020]                       return(sendCondition)
[17:29:26.020]                     ns <- getNamespace("parallel")
[17:29:26.020]                     if (exists("sendData", mode = "function", 
[17:29:26.020]                       envir = ns)) {
[17:29:26.020]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:26.020]                         envir = ns)
[17:29:26.020]                       envir <- sys.frame(frame)
[17:29:26.020]                       master <- NULL
[17:29:26.020]                       while (!identical(envir, .GlobalEnv) && 
[17:29:26.020]                         !identical(envir, emptyenv())) {
[17:29:26.020]                         if (exists("master", mode = "list", envir = envir, 
[17:29:26.020]                           inherits = FALSE)) {
[17:29:26.020]                           master <- get("master", mode = "list", 
[17:29:26.020]                             envir = envir, inherits = FALSE)
[17:29:26.020]                           if (inherits(master, c("SOCKnode", 
[17:29:26.020]                             "SOCK0node"))) {
[17:29:26.020]                             sendCondition <<- function(cond) {
[17:29:26.020]                               data <- list(type = "VALUE", value = cond, 
[17:29:26.020]                                 success = TRUE)
[17:29:26.020]                               parallel_sendData(master, data)
[17:29:26.020]                             }
[17:29:26.020]                             return(sendCondition)
[17:29:26.020]                           }
[17:29:26.020]                         }
[17:29:26.020]                         frame <- frame + 1L
[17:29:26.020]                         envir <- sys.frame(frame)
[17:29:26.020]                       }
[17:29:26.020]                     }
[17:29:26.020]                     sendCondition <<- function(cond) NULL
[17:29:26.020]                   }
[17:29:26.020]                 })
[17:29:26.020]                 withCallingHandlers({
[17:29:26.020]                   {
[17:29:26.020]                     1
[17:29:26.020]                   }
[17:29:26.020]                 }, immediateCondition = function(cond) {
[17:29:26.020]                   sendCondition <- ...future.makeSendCondition()
[17:29:26.020]                   sendCondition(cond)
[17:29:26.020]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.020]                   {
[17:29:26.020]                     inherits <- base::inherits
[17:29:26.020]                     invokeRestart <- base::invokeRestart
[17:29:26.020]                     is.null <- base::is.null
[17:29:26.020]                     muffled <- FALSE
[17:29:26.020]                     if (inherits(cond, "message")) {
[17:29:26.020]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:26.020]                       if (muffled) 
[17:29:26.020]                         invokeRestart("muffleMessage")
[17:29:26.020]                     }
[17:29:26.020]                     else if (inherits(cond, "warning")) {
[17:29:26.020]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:26.020]                       if (muffled) 
[17:29:26.020]                         invokeRestart("muffleWarning")
[17:29:26.020]                     }
[17:29:26.020]                     else if (inherits(cond, "condition")) {
[17:29:26.020]                       if (!is.null(pattern)) {
[17:29:26.020]                         computeRestarts <- base::computeRestarts
[17:29:26.020]                         grepl <- base::grepl
[17:29:26.020]                         restarts <- computeRestarts(cond)
[17:29:26.020]                         for (restart in restarts) {
[17:29:26.020]                           name <- restart$name
[17:29:26.020]                           if (is.null(name)) 
[17:29:26.020]                             next
[17:29:26.020]                           if (!grepl(pattern, name)) 
[17:29:26.020]                             next
[17:29:26.020]                           invokeRestart(restart)
[17:29:26.020]                           muffled <- TRUE
[17:29:26.020]                           break
[17:29:26.020]                         }
[17:29:26.020]                       }
[17:29:26.020]                     }
[17:29:26.020]                     invisible(muffled)
[17:29:26.020]                   }
[17:29:26.020]                   muffleCondition(cond)
[17:29:26.020]                 })
[17:29:26.020]             }))
[17:29:26.020]             future::FutureResult(value = ...future.value$value, 
[17:29:26.020]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:26.020]                   ...future.rng), globalenv = if (FALSE) 
[17:29:26.020]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:26.020]                     ...future.globalenv.names))
[17:29:26.020]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:26.020]         }, condition = base::local({
[17:29:26.020]             c <- base::c
[17:29:26.020]             inherits <- base::inherits
[17:29:26.020]             invokeRestart <- base::invokeRestart
[17:29:26.020]             length <- base::length
[17:29:26.020]             list <- base::list
[17:29:26.020]             seq.int <- base::seq.int
[17:29:26.020]             signalCondition <- base::signalCondition
[17:29:26.020]             sys.calls <- base::sys.calls
[17:29:26.020]             `[[` <- base::`[[`
[17:29:26.020]             `+` <- base::`+`
[17:29:26.020]             `<<-` <- base::`<<-`
[17:29:26.020]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:26.020]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:26.020]                   3L)]
[17:29:26.020]             }
[17:29:26.020]             function(cond) {
[17:29:26.020]                 is_error <- inherits(cond, "error")
[17:29:26.020]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:26.020]                   NULL)
[17:29:26.020]                 if (is_error) {
[17:29:26.020]                   sessionInformation <- function() {
[17:29:26.020]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:26.020]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:26.020]                       search = base::search(), system = base::Sys.info())
[17:29:26.020]                   }
[17:29:26.020]                   ...future.conditions[[length(...future.conditions) + 
[17:29:26.020]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:26.020]                     cond$call), session = sessionInformation(), 
[17:29:26.020]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:26.020]                   signalCondition(cond)
[17:29:26.020]                 }
[17:29:26.020]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:26.020]                 "immediateCondition"))) {
[17:29:26.020]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:26.020]                   ...future.conditions[[length(...future.conditions) + 
[17:29:26.020]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:26.020]                   if (TRUE && !signal) {
[17:29:26.020]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.020]                     {
[17:29:26.020]                       inherits <- base::inherits
[17:29:26.020]                       invokeRestart <- base::invokeRestart
[17:29:26.020]                       is.null <- base::is.null
[17:29:26.020]                       muffled <- FALSE
[17:29:26.020]                       if (inherits(cond, "message")) {
[17:29:26.020]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:26.020]                         if (muffled) 
[17:29:26.020]                           invokeRestart("muffleMessage")
[17:29:26.020]                       }
[17:29:26.020]                       else if (inherits(cond, "warning")) {
[17:29:26.020]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:26.020]                         if (muffled) 
[17:29:26.020]                           invokeRestart("muffleWarning")
[17:29:26.020]                       }
[17:29:26.020]                       else if (inherits(cond, "condition")) {
[17:29:26.020]                         if (!is.null(pattern)) {
[17:29:26.020]                           computeRestarts <- base::computeRestarts
[17:29:26.020]                           grepl <- base::grepl
[17:29:26.020]                           restarts <- computeRestarts(cond)
[17:29:26.020]                           for (restart in restarts) {
[17:29:26.020]                             name <- restart$name
[17:29:26.020]                             if (is.null(name)) 
[17:29:26.020]                               next
[17:29:26.020]                             if (!grepl(pattern, name)) 
[17:29:26.020]                               next
[17:29:26.020]                             invokeRestart(restart)
[17:29:26.020]                             muffled <- TRUE
[17:29:26.020]                             break
[17:29:26.020]                           }
[17:29:26.020]                         }
[17:29:26.020]                       }
[17:29:26.020]                       invisible(muffled)
[17:29:26.020]                     }
[17:29:26.020]                     muffleCondition(cond, pattern = "^muffle")
[17:29:26.020]                   }
[17:29:26.020]                 }
[17:29:26.020]                 else {
[17:29:26.020]                   if (TRUE) {
[17:29:26.020]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.020]                     {
[17:29:26.020]                       inherits <- base::inherits
[17:29:26.020]                       invokeRestart <- base::invokeRestart
[17:29:26.020]                       is.null <- base::is.null
[17:29:26.020]                       muffled <- FALSE
[17:29:26.020]                       if (inherits(cond, "message")) {
[17:29:26.020]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:26.020]                         if (muffled) 
[17:29:26.020]                           invokeRestart("muffleMessage")
[17:29:26.020]                       }
[17:29:26.020]                       else if (inherits(cond, "warning")) {
[17:29:26.020]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:26.020]                         if (muffled) 
[17:29:26.020]                           invokeRestart("muffleWarning")
[17:29:26.020]                       }
[17:29:26.020]                       else if (inherits(cond, "condition")) {
[17:29:26.020]                         if (!is.null(pattern)) {
[17:29:26.020]                           computeRestarts <- base::computeRestarts
[17:29:26.020]                           grepl <- base::grepl
[17:29:26.020]                           restarts <- computeRestarts(cond)
[17:29:26.020]                           for (restart in restarts) {
[17:29:26.020]                             name <- restart$name
[17:29:26.020]                             if (is.null(name)) 
[17:29:26.020]                               next
[17:29:26.020]                             if (!grepl(pattern, name)) 
[17:29:26.020]                               next
[17:29:26.020]                             invokeRestart(restart)
[17:29:26.020]                             muffled <- TRUE
[17:29:26.020]                             break
[17:29:26.020]                           }
[17:29:26.020]                         }
[17:29:26.020]                       }
[17:29:26.020]                       invisible(muffled)
[17:29:26.020]                     }
[17:29:26.020]                     muffleCondition(cond, pattern = "^muffle")
[17:29:26.020]                   }
[17:29:26.020]                 }
[17:29:26.020]             }
[17:29:26.020]         }))
[17:29:26.020]     }, error = function(ex) {
[17:29:26.020]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:26.020]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:26.020]                 ...future.rng), started = ...future.startTime, 
[17:29:26.020]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:26.020]             version = "1.8"), class = "FutureResult")
[17:29:26.020]     }, finally = {
[17:29:26.020]         if (!identical(...future.workdir, getwd())) 
[17:29:26.020]             setwd(...future.workdir)
[17:29:26.020]         {
[17:29:26.020]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:26.020]                 ...future.oldOptions$nwarnings <- NULL
[17:29:26.020]             }
[17:29:26.020]             base::options(...future.oldOptions)
[17:29:26.020]             if (.Platform$OS.type == "windows") {
[17:29:26.020]                 old_names <- names(...future.oldEnvVars)
[17:29:26.020]                 envs <- base::Sys.getenv()
[17:29:26.020]                 names <- names(envs)
[17:29:26.020]                 common <- intersect(names, old_names)
[17:29:26.020]                 added <- setdiff(names, old_names)
[17:29:26.020]                 removed <- setdiff(old_names, names)
[17:29:26.020]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:26.020]                   envs[common]]
[17:29:26.020]                 NAMES <- toupper(changed)
[17:29:26.020]                 args <- list()
[17:29:26.020]                 for (kk in seq_along(NAMES)) {
[17:29:26.020]                   name <- changed[[kk]]
[17:29:26.020]                   NAME <- NAMES[[kk]]
[17:29:26.020]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.020]                     next
[17:29:26.020]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:26.020]                 }
[17:29:26.020]                 NAMES <- toupper(added)
[17:29:26.020]                 for (kk in seq_along(NAMES)) {
[17:29:26.020]                   name <- added[[kk]]
[17:29:26.020]                   NAME <- NAMES[[kk]]
[17:29:26.020]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.020]                     next
[17:29:26.020]                   args[[name]] <- ""
[17:29:26.020]                 }
[17:29:26.020]                 NAMES <- toupper(removed)
[17:29:26.020]                 for (kk in seq_along(NAMES)) {
[17:29:26.020]                   name <- removed[[kk]]
[17:29:26.020]                   NAME <- NAMES[[kk]]
[17:29:26.020]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.020]                     next
[17:29:26.020]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:26.020]                 }
[17:29:26.020]                 if (length(args) > 0) 
[17:29:26.020]                   base::do.call(base::Sys.setenv, args = args)
[17:29:26.020]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:26.020]             }
[17:29:26.020]             else {
[17:29:26.020]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:26.020]             }
[17:29:26.020]             {
[17:29:26.020]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:26.020]                   0L) {
[17:29:26.020]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:26.020]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:26.020]                   base::options(opts)
[17:29:26.020]                 }
[17:29:26.020]                 {
[17:29:26.020]                   {
[17:29:26.020]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:26.020]                     NULL
[17:29:26.020]                   }
[17:29:26.020]                   options(future.plan = NULL)
[17:29:26.020]                   if (is.na(NA_character_)) 
[17:29:26.020]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:26.020]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:26.020]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:26.020]                     .init = FALSE)
[17:29:26.020]                 }
[17:29:26.020]             }
[17:29:26.020]         }
[17:29:26.020]     })
[17:29:26.020]     if (TRUE) {
[17:29:26.020]         base::sink(type = "output", split = FALSE)
[17:29:26.020]         if (TRUE) {
[17:29:26.020]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:26.020]         }
[17:29:26.020]         else {
[17:29:26.020]             ...future.result["stdout"] <- base::list(NULL)
[17:29:26.020]         }
[17:29:26.020]         base::close(...future.stdout)
[17:29:26.020]         ...future.stdout <- NULL
[17:29:26.020]     }
[17:29:26.020]     ...future.result$conditions <- ...future.conditions
[17:29:26.020]     ...future.result$finished <- base::Sys.time()
[17:29:26.020]     ...future.result
[17:29:26.020] }
[17:29:26.029] MultisessionFuture started
[17:29:26.029] - Launch lazy future ... done
[17:29:26.029] run() for 'MultisessionFuture' ... done
[17:29:26.030] getGlobalsAndPackages() ...
[17:29:26.031] Searching for globals...
[17:29:26.032] - globals found: [1] '{'
[17:29:26.032] Searching for globals ... DONE
[17:29:26.032] Resolving globals: FALSE
[17:29:26.033] 
[17:29:26.033] 
[17:29:26.033] getGlobalsAndPackages() ... DONE
[17:29:26.034] run() for 'Future' ...
[17:29:26.034] - state: 'created'
[17:29:26.035] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:26.053] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:26.054] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:26.054]   - Field: 'node'
[17:29:26.054]   - Field: 'label'
[17:29:26.055]   - Field: 'local'
[17:29:26.055]   - Field: 'owner'
[17:29:26.055]   - Field: 'envir'
[17:29:26.055]   - Field: 'workers'
[17:29:26.055]   - Field: 'packages'
[17:29:26.055]   - Field: 'gc'
[17:29:26.056]   - Field: 'conditions'
[17:29:26.056]   - Field: 'persistent'
[17:29:26.056]   - Field: 'expr'
[17:29:26.056]   - Field: 'uuid'
[17:29:26.056]   - Field: 'seed'
[17:29:26.056]   - Field: 'version'
[17:29:26.057]   - Field: 'result'
[17:29:26.057]   - Field: 'asynchronous'
[17:29:26.057]   - Field: 'calls'
[17:29:26.057]   - Field: 'globals'
[17:29:26.057]   - Field: 'stdout'
[17:29:26.058]   - Field: 'earlySignal'
[17:29:26.058]   - Field: 'lazy'
[17:29:26.058]   - Field: 'state'
[17:29:26.058] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:26.058] - Launch lazy future ...
[17:29:26.059] Packages needed by the future expression (n = 0): <none>
[17:29:26.059] Packages needed by future strategies (n = 0): <none>
[17:29:26.059] {
[17:29:26.059]     {
[17:29:26.059]         {
[17:29:26.059]             ...future.startTime <- base::Sys.time()
[17:29:26.059]             {
[17:29:26.059]                 {
[17:29:26.059]                   {
[17:29:26.059]                     {
[17:29:26.059]                       base::local({
[17:29:26.059]                         has_future <- base::requireNamespace("future", 
[17:29:26.059]                           quietly = TRUE)
[17:29:26.059]                         if (has_future) {
[17:29:26.059]                           ns <- base::getNamespace("future")
[17:29:26.059]                           version <- ns[[".package"]][["version"]]
[17:29:26.059]                           if (is.null(version)) 
[17:29:26.059]                             version <- utils::packageVersion("future")
[17:29:26.059]                         }
[17:29:26.059]                         else {
[17:29:26.059]                           version <- NULL
[17:29:26.059]                         }
[17:29:26.059]                         if (!has_future || version < "1.8.0") {
[17:29:26.059]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:26.059]                             "", base::R.version$version.string), 
[17:29:26.059]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:26.059]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:26.059]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:26.059]                               "release", "version")], collapse = " "), 
[17:29:26.059]                             hostname = base::Sys.info()[["nodename"]])
[17:29:26.059]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:26.059]                             info)
[17:29:26.059]                           info <- base::paste(info, collapse = "; ")
[17:29:26.059]                           if (!has_future) {
[17:29:26.059]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:26.059]                               info)
[17:29:26.059]                           }
[17:29:26.059]                           else {
[17:29:26.059]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:26.059]                               info, version)
[17:29:26.059]                           }
[17:29:26.059]                           base::stop(msg)
[17:29:26.059]                         }
[17:29:26.059]                       })
[17:29:26.059]                     }
[17:29:26.059]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:26.059]                     base::options(mc.cores = 1L)
[17:29:26.059]                   }
[17:29:26.059]                   ...future.strategy.old <- future::plan("list")
[17:29:26.059]                   options(future.plan = NULL)
[17:29:26.059]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:26.059]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:26.059]                 }
[17:29:26.059]                 ...future.workdir <- getwd()
[17:29:26.059]             }
[17:29:26.059]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:26.059]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:26.059]         }
[17:29:26.059]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:26.059]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:26.059]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:26.059]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:26.059]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:26.059]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:26.059]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:26.059]             base::names(...future.oldOptions))
[17:29:26.059]     }
[17:29:26.059]     if (FALSE) {
[17:29:26.059]     }
[17:29:26.059]     else {
[17:29:26.059]         if (TRUE) {
[17:29:26.059]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:26.059]                 open = "w")
[17:29:26.059]         }
[17:29:26.059]         else {
[17:29:26.059]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:26.059]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:26.059]         }
[17:29:26.059]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:26.059]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:26.059]             base::sink(type = "output", split = FALSE)
[17:29:26.059]             base::close(...future.stdout)
[17:29:26.059]         }, add = TRUE)
[17:29:26.059]     }
[17:29:26.059]     ...future.frame <- base::sys.nframe()
[17:29:26.059]     ...future.conditions <- base::list()
[17:29:26.059]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:26.059]     if (FALSE) {
[17:29:26.059]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:26.059]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:26.059]     }
[17:29:26.059]     ...future.result <- base::tryCatch({
[17:29:26.059]         base::withCallingHandlers({
[17:29:26.059]             ...future.value <- base::withVisible(base::local({
[17:29:26.059]                 ...future.makeSendCondition <- base::local({
[17:29:26.059]                   sendCondition <- NULL
[17:29:26.059]                   function(frame = 1L) {
[17:29:26.059]                     if (is.function(sendCondition)) 
[17:29:26.059]                       return(sendCondition)
[17:29:26.059]                     ns <- getNamespace("parallel")
[17:29:26.059]                     if (exists("sendData", mode = "function", 
[17:29:26.059]                       envir = ns)) {
[17:29:26.059]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:26.059]                         envir = ns)
[17:29:26.059]                       envir <- sys.frame(frame)
[17:29:26.059]                       master <- NULL
[17:29:26.059]                       while (!identical(envir, .GlobalEnv) && 
[17:29:26.059]                         !identical(envir, emptyenv())) {
[17:29:26.059]                         if (exists("master", mode = "list", envir = envir, 
[17:29:26.059]                           inherits = FALSE)) {
[17:29:26.059]                           master <- get("master", mode = "list", 
[17:29:26.059]                             envir = envir, inherits = FALSE)
[17:29:26.059]                           if (inherits(master, c("SOCKnode", 
[17:29:26.059]                             "SOCK0node"))) {
[17:29:26.059]                             sendCondition <<- function(cond) {
[17:29:26.059]                               data <- list(type = "VALUE", value = cond, 
[17:29:26.059]                                 success = TRUE)
[17:29:26.059]                               parallel_sendData(master, data)
[17:29:26.059]                             }
[17:29:26.059]                             return(sendCondition)
[17:29:26.059]                           }
[17:29:26.059]                         }
[17:29:26.059]                         frame <- frame + 1L
[17:29:26.059]                         envir <- sys.frame(frame)
[17:29:26.059]                       }
[17:29:26.059]                     }
[17:29:26.059]                     sendCondition <<- function(cond) NULL
[17:29:26.059]                   }
[17:29:26.059]                 })
[17:29:26.059]                 withCallingHandlers({
[17:29:26.059]                   {
[17:29:26.059]                     2
[17:29:26.059]                   }
[17:29:26.059]                 }, immediateCondition = function(cond) {
[17:29:26.059]                   sendCondition <- ...future.makeSendCondition()
[17:29:26.059]                   sendCondition(cond)
[17:29:26.059]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.059]                   {
[17:29:26.059]                     inherits <- base::inherits
[17:29:26.059]                     invokeRestart <- base::invokeRestart
[17:29:26.059]                     is.null <- base::is.null
[17:29:26.059]                     muffled <- FALSE
[17:29:26.059]                     if (inherits(cond, "message")) {
[17:29:26.059]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:26.059]                       if (muffled) 
[17:29:26.059]                         invokeRestart("muffleMessage")
[17:29:26.059]                     }
[17:29:26.059]                     else if (inherits(cond, "warning")) {
[17:29:26.059]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:26.059]                       if (muffled) 
[17:29:26.059]                         invokeRestart("muffleWarning")
[17:29:26.059]                     }
[17:29:26.059]                     else if (inherits(cond, "condition")) {
[17:29:26.059]                       if (!is.null(pattern)) {
[17:29:26.059]                         computeRestarts <- base::computeRestarts
[17:29:26.059]                         grepl <- base::grepl
[17:29:26.059]                         restarts <- computeRestarts(cond)
[17:29:26.059]                         for (restart in restarts) {
[17:29:26.059]                           name <- restart$name
[17:29:26.059]                           if (is.null(name)) 
[17:29:26.059]                             next
[17:29:26.059]                           if (!grepl(pattern, name)) 
[17:29:26.059]                             next
[17:29:26.059]                           invokeRestart(restart)
[17:29:26.059]                           muffled <- TRUE
[17:29:26.059]                           break
[17:29:26.059]                         }
[17:29:26.059]                       }
[17:29:26.059]                     }
[17:29:26.059]                     invisible(muffled)
[17:29:26.059]                   }
[17:29:26.059]                   muffleCondition(cond)
[17:29:26.059]                 })
[17:29:26.059]             }))
[17:29:26.059]             future::FutureResult(value = ...future.value$value, 
[17:29:26.059]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:26.059]                   ...future.rng), globalenv = if (FALSE) 
[17:29:26.059]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:26.059]                     ...future.globalenv.names))
[17:29:26.059]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:26.059]         }, condition = base::local({
[17:29:26.059]             c <- base::c
[17:29:26.059]             inherits <- base::inherits
[17:29:26.059]             invokeRestart <- base::invokeRestart
[17:29:26.059]             length <- base::length
[17:29:26.059]             list <- base::list
[17:29:26.059]             seq.int <- base::seq.int
[17:29:26.059]             signalCondition <- base::signalCondition
[17:29:26.059]             sys.calls <- base::sys.calls
[17:29:26.059]             `[[` <- base::`[[`
[17:29:26.059]             `+` <- base::`+`
[17:29:26.059]             `<<-` <- base::`<<-`
[17:29:26.059]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:26.059]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:26.059]                   3L)]
[17:29:26.059]             }
[17:29:26.059]             function(cond) {
[17:29:26.059]                 is_error <- inherits(cond, "error")
[17:29:26.059]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:26.059]                   NULL)
[17:29:26.059]                 if (is_error) {
[17:29:26.059]                   sessionInformation <- function() {
[17:29:26.059]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:26.059]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:26.059]                       search = base::search(), system = base::Sys.info())
[17:29:26.059]                   }
[17:29:26.059]                   ...future.conditions[[length(...future.conditions) + 
[17:29:26.059]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:26.059]                     cond$call), session = sessionInformation(), 
[17:29:26.059]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:26.059]                   signalCondition(cond)
[17:29:26.059]                 }
[17:29:26.059]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:26.059]                 "immediateCondition"))) {
[17:29:26.059]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:26.059]                   ...future.conditions[[length(...future.conditions) + 
[17:29:26.059]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:26.059]                   if (TRUE && !signal) {
[17:29:26.059]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.059]                     {
[17:29:26.059]                       inherits <- base::inherits
[17:29:26.059]                       invokeRestart <- base::invokeRestart
[17:29:26.059]                       is.null <- base::is.null
[17:29:26.059]                       muffled <- FALSE
[17:29:26.059]                       if (inherits(cond, "message")) {
[17:29:26.059]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:26.059]                         if (muffled) 
[17:29:26.059]                           invokeRestart("muffleMessage")
[17:29:26.059]                       }
[17:29:26.059]                       else if (inherits(cond, "warning")) {
[17:29:26.059]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:26.059]                         if (muffled) 
[17:29:26.059]                           invokeRestart("muffleWarning")
[17:29:26.059]                       }
[17:29:26.059]                       else if (inherits(cond, "condition")) {
[17:29:26.059]                         if (!is.null(pattern)) {
[17:29:26.059]                           computeRestarts <- base::computeRestarts
[17:29:26.059]                           grepl <- base::grepl
[17:29:26.059]                           restarts <- computeRestarts(cond)
[17:29:26.059]                           for (restart in restarts) {
[17:29:26.059]                             name <- restart$name
[17:29:26.059]                             if (is.null(name)) 
[17:29:26.059]                               next
[17:29:26.059]                             if (!grepl(pattern, name)) 
[17:29:26.059]                               next
[17:29:26.059]                             invokeRestart(restart)
[17:29:26.059]                             muffled <- TRUE
[17:29:26.059]                             break
[17:29:26.059]                           }
[17:29:26.059]                         }
[17:29:26.059]                       }
[17:29:26.059]                       invisible(muffled)
[17:29:26.059]                     }
[17:29:26.059]                     muffleCondition(cond, pattern = "^muffle")
[17:29:26.059]                   }
[17:29:26.059]                 }
[17:29:26.059]                 else {
[17:29:26.059]                   if (TRUE) {
[17:29:26.059]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.059]                     {
[17:29:26.059]                       inherits <- base::inherits
[17:29:26.059]                       invokeRestart <- base::invokeRestart
[17:29:26.059]                       is.null <- base::is.null
[17:29:26.059]                       muffled <- FALSE
[17:29:26.059]                       if (inherits(cond, "message")) {
[17:29:26.059]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:26.059]                         if (muffled) 
[17:29:26.059]                           invokeRestart("muffleMessage")
[17:29:26.059]                       }
[17:29:26.059]                       else if (inherits(cond, "warning")) {
[17:29:26.059]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:26.059]                         if (muffled) 
[17:29:26.059]                           invokeRestart("muffleWarning")
[17:29:26.059]                       }
[17:29:26.059]                       else if (inherits(cond, "condition")) {
[17:29:26.059]                         if (!is.null(pattern)) {
[17:29:26.059]                           computeRestarts <- base::computeRestarts
[17:29:26.059]                           grepl <- base::grepl
[17:29:26.059]                           restarts <- computeRestarts(cond)
[17:29:26.059]                           for (restart in restarts) {
[17:29:26.059]                             name <- restart$name
[17:29:26.059]                             if (is.null(name)) 
[17:29:26.059]                               next
[17:29:26.059]                             if (!grepl(pattern, name)) 
[17:29:26.059]                               next
[17:29:26.059]                             invokeRestart(restart)
[17:29:26.059]                             muffled <- TRUE
[17:29:26.059]                             break
[17:29:26.059]                           }
[17:29:26.059]                         }
[17:29:26.059]                       }
[17:29:26.059]                       invisible(muffled)
[17:29:26.059]                     }
[17:29:26.059]                     muffleCondition(cond, pattern = "^muffle")
[17:29:26.059]                   }
[17:29:26.059]                 }
[17:29:26.059]             }
[17:29:26.059]         }))
[17:29:26.059]     }, error = function(ex) {
[17:29:26.059]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:26.059]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:26.059]                 ...future.rng), started = ...future.startTime, 
[17:29:26.059]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:26.059]             version = "1.8"), class = "FutureResult")
[17:29:26.059]     }, finally = {
[17:29:26.059]         if (!identical(...future.workdir, getwd())) 
[17:29:26.059]             setwd(...future.workdir)
[17:29:26.059]         {
[17:29:26.059]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:26.059]                 ...future.oldOptions$nwarnings <- NULL
[17:29:26.059]             }
[17:29:26.059]             base::options(...future.oldOptions)
[17:29:26.059]             if (.Platform$OS.type == "windows") {
[17:29:26.059]                 old_names <- names(...future.oldEnvVars)
[17:29:26.059]                 envs <- base::Sys.getenv()
[17:29:26.059]                 names <- names(envs)
[17:29:26.059]                 common <- intersect(names, old_names)
[17:29:26.059]                 added <- setdiff(names, old_names)
[17:29:26.059]                 removed <- setdiff(old_names, names)
[17:29:26.059]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:26.059]                   envs[common]]
[17:29:26.059]                 NAMES <- toupper(changed)
[17:29:26.059]                 args <- list()
[17:29:26.059]                 for (kk in seq_along(NAMES)) {
[17:29:26.059]                   name <- changed[[kk]]
[17:29:26.059]                   NAME <- NAMES[[kk]]
[17:29:26.059]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.059]                     next
[17:29:26.059]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:26.059]                 }
[17:29:26.059]                 NAMES <- toupper(added)
[17:29:26.059]                 for (kk in seq_along(NAMES)) {
[17:29:26.059]                   name <- added[[kk]]
[17:29:26.059]                   NAME <- NAMES[[kk]]
[17:29:26.059]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.059]                     next
[17:29:26.059]                   args[[name]] <- ""
[17:29:26.059]                 }
[17:29:26.059]                 NAMES <- toupper(removed)
[17:29:26.059]                 for (kk in seq_along(NAMES)) {
[17:29:26.059]                   name <- removed[[kk]]
[17:29:26.059]                   NAME <- NAMES[[kk]]
[17:29:26.059]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.059]                     next
[17:29:26.059]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:26.059]                 }
[17:29:26.059]                 if (length(args) > 0) 
[17:29:26.059]                   base::do.call(base::Sys.setenv, args = args)
[17:29:26.059]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:26.059]             }
[17:29:26.059]             else {
[17:29:26.059]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:26.059]             }
[17:29:26.059]             {
[17:29:26.059]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:26.059]                   0L) {
[17:29:26.059]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:26.059]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:26.059]                   base::options(opts)
[17:29:26.059]                 }
[17:29:26.059]                 {
[17:29:26.059]                   {
[17:29:26.059]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:26.059]                     NULL
[17:29:26.059]                   }
[17:29:26.059]                   options(future.plan = NULL)
[17:29:26.059]                   if (is.na(NA_character_)) 
[17:29:26.059]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:26.059]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:26.059]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:26.059]                     .init = FALSE)
[17:29:26.059]                 }
[17:29:26.059]             }
[17:29:26.059]         }
[17:29:26.059]     })
[17:29:26.059]     if (TRUE) {
[17:29:26.059]         base::sink(type = "output", split = FALSE)
[17:29:26.059]         if (TRUE) {
[17:29:26.059]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:26.059]         }
[17:29:26.059]         else {
[17:29:26.059]             ...future.result["stdout"] <- base::list(NULL)
[17:29:26.059]         }
[17:29:26.059]         base::close(...future.stdout)
[17:29:26.059]         ...future.stdout <- NULL
[17:29:26.059]     }
[17:29:26.059]     ...future.result$conditions <- ...future.conditions
[17:29:26.059]     ...future.result$finished <- base::Sys.time()
[17:29:26.059]     ...future.result
[17:29:26.059] }
[17:29:26.066] MultisessionFuture started
[17:29:26.066] - Launch lazy future ... done
[17:29:26.066] run() for 'MultisessionFuture' ... done
[17:29:26.067] resolve() on environment ...
[17:29:26.068]  recursive: 0
[17:29:26.069]  elements: [3] '.future_a', '.future_b', 'a', 'b', 'c'
[17:29:26.069] receiveMessageFromWorker() for ClusterFuture ...
[17:29:26.070] - Validating connection of MultisessionFuture
[17:29:26.070] - received message: FutureResult
[17:29:26.070] - Received FutureResult
[17:29:26.071] - Erased future from FutureRegistry
[17:29:26.071] result() for ClusterFuture ...
[17:29:26.071] - result already collected: FutureResult
[17:29:26.071] result() for ClusterFuture ... done
[17:29:26.072] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:26.072] Future #1
[17:29:26.072]  length: 2 (resolved future 1)
[17:29:26.086] receiveMessageFromWorker() for ClusterFuture ...
[17:29:26.086] - Validating connection of MultisessionFuture
[17:29:26.086] - received message: FutureResult
[17:29:26.087] - Received FutureResult
[17:29:26.087] - Erased future from FutureRegistry
[17:29:26.087] result() for ClusterFuture ...
[17:29:26.087] - result already collected: FutureResult
[17:29:26.087] result() for ClusterFuture ... done
[17:29:26.088] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:26.088] Future #2
[17:29:26.088]  length: 1 (resolved future 2)
[17:29:26.088]  length: 0 (resolved future 3)
[17:29:26.088] resolve() on environment ... DONE
[17:29:26.089] getGlobalsAndPackages() ...
[17:29:26.089] Searching for globals...
[17:29:26.090] - globals found: [1] '{'
[17:29:26.090] Searching for globals ... DONE
[17:29:26.090] Resolving globals: FALSE
[17:29:26.091] 
[17:29:26.091] 
[17:29:26.091] getGlobalsAndPackages() ... DONE
[17:29:26.091] run() for 'Future' ...
[17:29:26.092] - state: 'created'
[17:29:26.092] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:26.109] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:26.109] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:26.109]   - Field: 'node'
[17:29:26.110]   - Field: 'label'
[17:29:26.110]   - Field: 'local'
[17:29:26.110]   - Field: 'owner'
[17:29:26.110]   - Field: 'envir'
[17:29:26.110]   - Field: 'workers'
[17:29:26.111]   - Field: 'packages'
[17:29:26.111]   - Field: 'gc'
[17:29:26.111]   - Field: 'conditions'
[17:29:26.111]   - Field: 'persistent'
[17:29:26.111]   - Field: 'expr'
[17:29:26.112]   - Field: 'uuid'
[17:29:26.112]   - Field: 'seed'
[17:29:26.112]   - Field: 'version'
[17:29:26.112]   - Field: 'result'
[17:29:26.113]   - Field: 'asynchronous'
[17:29:26.113]   - Field: 'calls'
[17:29:26.113]   - Field: 'globals'
[17:29:26.113]   - Field: 'stdout'
[17:29:26.114]   - Field: 'earlySignal'
[17:29:26.114]   - Field: 'lazy'
[17:29:26.114]   - Field: 'state'
[17:29:26.114] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:26.114] - Launch lazy future ...
[17:29:26.115] Packages needed by the future expression (n = 0): <none>
[17:29:26.115] Packages needed by future strategies (n = 0): <none>
[17:29:26.116] {
[17:29:26.116]     {
[17:29:26.116]         {
[17:29:26.116]             ...future.startTime <- base::Sys.time()
[17:29:26.116]             {
[17:29:26.116]                 {
[17:29:26.116]                   {
[17:29:26.116]                     {
[17:29:26.116]                       base::local({
[17:29:26.116]                         has_future <- base::requireNamespace("future", 
[17:29:26.116]                           quietly = TRUE)
[17:29:26.116]                         if (has_future) {
[17:29:26.116]                           ns <- base::getNamespace("future")
[17:29:26.116]                           version <- ns[[".package"]][["version"]]
[17:29:26.116]                           if (is.null(version)) 
[17:29:26.116]                             version <- utils::packageVersion("future")
[17:29:26.116]                         }
[17:29:26.116]                         else {
[17:29:26.116]                           version <- NULL
[17:29:26.116]                         }
[17:29:26.116]                         if (!has_future || version < "1.8.0") {
[17:29:26.116]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:26.116]                             "", base::R.version$version.string), 
[17:29:26.116]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:26.116]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:26.116]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:26.116]                               "release", "version")], collapse = " "), 
[17:29:26.116]                             hostname = base::Sys.info()[["nodename"]])
[17:29:26.116]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:26.116]                             info)
[17:29:26.116]                           info <- base::paste(info, collapse = "; ")
[17:29:26.116]                           if (!has_future) {
[17:29:26.116]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:26.116]                               info)
[17:29:26.116]                           }
[17:29:26.116]                           else {
[17:29:26.116]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:26.116]                               info, version)
[17:29:26.116]                           }
[17:29:26.116]                           base::stop(msg)
[17:29:26.116]                         }
[17:29:26.116]                       })
[17:29:26.116]                     }
[17:29:26.116]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:26.116]                     base::options(mc.cores = 1L)
[17:29:26.116]                   }
[17:29:26.116]                   ...future.strategy.old <- future::plan("list")
[17:29:26.116]                   options(future.plan = NULL)
[17:29:26.116]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:26.116]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:26.116]                 }
[17:29:26.116]                 ...future.workdir <- getwd()
[17:29:26.116]             }
[17:29:26.116]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:26.116]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:26.116]         }
[17:29:26.116]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:26.116]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:26.116]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:26.116]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:26.116]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:26.116]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:26.116]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:26.116]             base::names(...future.oldOptions))
[17:29:26.116]     }
[17:29:26.116]     if (FALSE) {
[17:29:26.116]     }
[17:29:26.116]     else {
[17:29:26.116]         if (TRUE) {
[17:29:26.116]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:26.116]                 open = "w")
[17:29:26.116]         }
[17:29:26.116]         else {
[17:29:26.116]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:26.116]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:26.116]         }
[17:29:26.116]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:26.116]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:26.116]             base::sink(type = "output", split = FALSE)
[17:29:26.116]             base::close(...future.stdout)
[17:29:26.116]         }, add = TRUE)
[17:29:26.116]     }
[17:29:26.116]     ...future.frame <- base::sys.nframe()
[17:29:26.116]     ...future.conditions <- base::list()
[17:29:26.116]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:26.116]     if (FALSE) {
[17:29:26.116]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:26.116]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:26.116]     }
[17:29:26.116]     ...future.result <- base::tryCatch({
[17:29:26.116]         base::withCallingHandlers({
[17:29:26.116]             ...future.value <- base::withVisible(base::local({
[17:29:26.116]                 ...future.makeSendCondition <- base::local({
[17:29:26.116]                   sendCondition <- NULL
[17:29:26.116]                   function(frame = 1L) {
[17:29:26.116]                     if (is.function(sendCondition)) 
[17:29:26.116]                       return(sendCondition)
[17:29:26.116]                     ns <- getNamespace("parallel")
[17:29:26.116]                     if (exists("sendData", mode = "function", 
[17:29:26.116]                       envir = ns)) {
[17:29:26.116]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:26.116]                         envir = ns)
[17:29:26.116]                       envir <- sys.frame(frame)
[17:29:26.116]                       master <- NULL
[17:29:26.116]                       while (!identical(envir, .GlobalEnv) && 
[17:29:26.116]                         !identical(envir, emptyenv())) {
[17:29:26.116]                         if (exists("master", mode = "list", envir = envir, 
[17:29:26.116]                           inherits = FALSE)) {
[17:29:26.116]                           master <- get("master", mode = "list", 
[17:29:26.116]                             envir = envir, inherits = FALSE)
[17:29:26.116]                           if (inherits(master, c("SOCKnode", 
[17:29:26.116]                             "SOCK0node"))) {
[17:29:26.116]                             sendCondition <<- function(cond) {
[17:29:26.116]                               data <- list(type = "VALUE", value = cond, 
[17:29:26.116]                                 success = TRUE)
[17:29:26.116]                               parallel_sendData(master, data)
[17:29:26.116]                             }
[17:29:26.116]                             return(sendCondition)
[17:29:26.116]                           }
[17:29:26.116]                         }
[17:29:26.116]                         frame <- frame + 1L
[17:29:26.116]                         envir <- sys.frame(frame)
[17:29:26.116]                       }
[17:29:26.116]                     }
[17:29:26.116]                     sendCondition <<- function(cond) NULL
[17:29:26.116]                   }
[17:29:26.116]                 })
[17:29:26.116]                 withCallingHandlers({
[17:29:26.116]                   {
[17:29:26.116]                     1
[17:29:26.116]                   }
[17:29:26.116]                 }, immediateCondition = function(cond) {
[17:29:26.116]                   sendCondition <- ...future.makeSendCondition()
[17:29:26.116]                   sendCondition(cond)
[17:29:26.116]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.116]                   {
[17:29:26.116]                     inherits <- base::inherits
[17:29:26.116]                     invokeRestart <- base::invokeRestart
[17:29:26.116]                     is.null <- base::is.null
[17:29:26.116]                     muffled <- FALSE
[17:29:26.116]                     if (inherits(cond, "message")) {
[17:29:26.116]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:26.116]                       if (muffled) 
[17:29:26.116]                         invokeRestart("muffleMessage")
[17:29:26.116]                     }
[17:29:26.116]                     else if (inherits(cond, "warning")) {
[17:29:26.116]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:26.116]                       if (muffled) 
[17:29:26.116]                         invokeRestart("muffleWarning")
[17:29:26.116]                     }
[17:29:26.116]                     else if (inherits(cond, "condition")) {
[17:29:26.116]                       if (!is.null(pattern)) {
[17:29:26.116]                         computeRestarts <- base::computeRestarts
[17:29:26.116]                         grepl <- base::grepl
[17:29:26.116]                         restarts <- computeRestarts(cond)
[17:29:26.116]                         for (restart in restarts) {
[17:29:26.116]                           name <- restart$name
[17:29:26.116]                           if (is.null(name)) 
[17:29:26.116]                             next
[17:29:26.116]                           if (!grepl(pattern, name)) 
[17:29:26.116]                             next
[17:29:26.116]                           invokeRestart(restart)
[17:29:26.116]                           muffled <- TRUE
[17:29:26.116]                           break
[17:29:26.116]                         }
[17:29:26.116]                       }
[17:29:26.116]                     }
[17:29:26.116]                     invisible(muffled)
[17:29:26.116]                   }
[17:29:26.116]                   muffleCondition(cond)
[17:29:26.116]                 })
[17:29:26.116]             }))
[17:29:26.116]             future::FutureResult(value = ...future.value$value, 
[17:29:26.116]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:26.116]                   ...future.rng), globalenv = if (FALSE) 
[17:29:26.116]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:26.116]                     ...future.globalenv.names))
[17:29:26.116]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:26.116]         }, condition = base::local({
[17:29:26.116]             c <- base::c
[17:29:26.116]             inherits <- base::inherits
[17:29:26.116]             invokeRestart <- base::invokeRestart
[17:29:26.116]             length <- base::length
[17:29:26.116]             list <- base::list
[17:29:26.116]             seq.int <- base::seq.int
[17:29:26.116]             signalCondition <- base::signalCondition
[17:29:26.116]             sys.calls <- base::sys.calls
[17:29:26.116]             `[[` <- base::`[[`
[17:29:26.116]             `+` <- base::`+`
[17:29:26.116]             `<<-` <- base::`<<-`
[17:29:26.116]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:26.116]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:26.116]                   3L)]
[17:29:26.116]             }
[17:29:26.116]             function(cond) {
[17:29:26.116]                 is_error <- inherits(cond, "error")
[17:29:26.116]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:26.116]                   NULL)
[17:29:26.116]                 if (is_error) {
[17:29:26.116]                   sessionInformation <- function() {
[17:29:26.116]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:26.116]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:26.116]                       search = base::search(), system = base::Sys.info())
[17:29:26.116]                   }
[17:29:26.116]                   ...future.conditions[[length(...future.conditions) + 
[17:29:26.116]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:26.116]                     cond$call), session = sessionInformation(), 
[17:29:26.116]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:26.116]                   signalCondition(cond)
[17:29:26.116]                 }
[17:29:26.116]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:26.116]                 "immediateCondition"))) {
[17:29:26.116]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:26.116]                   ...future.conditions[[length(...future.conditions) + 
[17:29:26.116]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:26.116]                   if (TRUE && !signal) {
[17:29:26.116]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.116]                     {
[17:29:26.116]                       inherits <- base::inherits
[17:29:26.116]                       invokeRestart <- base::invokeRestart
[17:29:26.116]                       is.null <- base::is.null
[17:29:26.116]                       muffled <- FALSE
[17:29:26.116]                       if (inherits(cond, "message")) {
[17:29:26.116]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:26.116]                         if (muffled) 
[17:29:26.116]                           invokeRestart("muffleMessage")
[17:29:26.116]                       }
[17:29:26.116]                       else if (inherits(cond, "warning")) {
[17:29:26.116]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:26.116]                         if (muffled) 
[17:29:26.116]                           invokeRestart("muffleWarning")
[17:29:26.116]                       }
[17:29:26.116]                       else if (inherits(cond, "condition")) {
[17:29:26.116]                         if (!is.null(pattern)) {
[17:29:26.116]                           computeRestarts <- base::computeRestarts
[17:29:26.116]                           grepl <- base::grepl
[17:29:26.116]                           restarts <- computeRestarts(cond)
[17:29:26.116]                           for (restart in restarts) {
[17:29:26.116]                             name <- restart$name
[17:29:26.116]                             if (is.null(name)) 
[17:29:26.116]                               next
[17:29:26.116]                             if (!grepl(pattern, name)) 
[17:29:26.116]                               next
[17:29:26.116]                             invokeRestart(restart)
[17:29:26.116]                             muffled <- TRUE
[17:29:26.116]                             break
[17:29:26.116]                           }
[17:29:26.116]                         }
[17:29:26.116]                       }
[17:29:26.116]                       invisible(muffled)
[17:29:26.116]                     }
[17:29:26.116]                     muffleCondition(cond, pattern = "^muffle")
[17:29:26.116]                   }
[17:29:26.116]                 }
[17:29:26.116]                 else {
[17:29:26.116]                   if (TRUE) {
[17:29:26.116]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.116]                     {
[17:29:26.116]                       inherits <- base::inherits
[17:29:26.116]                       invokeRestart <- base::invokeRestart
[17:29:26.116]                       is.null <- base::is.null
[17:29:26.116]                       muffled <- FALSE
[17:29:26.116]                       if (inherits(cond, "message")) {
[17:29:26.116]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:26.116]                         if (muffled) 
[17:29:26.116]                           invokeRestart("muffleMessage")
[17:29:26.116]                       }
[17:29:26.116]                       else if (inherits(cond, "warning")) {
[17:29:26.116]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:26.116]                         if (muffled) 
[17:29:26.116]                           invokeRestart("muffleWarning")
[17:29:26.116]                       }
[17:29:26.116]                       else if (inherits(cond, "condition")) {
[17:29:26.116]                         if (!is.null(pattern)) {
[17:29:26.116]                           computeRestarts <- base::computeRestarts
[17:29:26.116]                           grepl <- base::grepl
[17:29:26.116]                           restarts <- computeRestarts(cond)
[17:29:26.116]                           for (restart in restarts) {
[17:29:26.116]                             name <- restart$name
[17:29:26.116]                             if (is.null(name)) 
[17:29:26.116]                               next
[17:29:26.116]                             if (!grepl(pattern, name)) 
[17:29:26.116]                               next
[17:29:26.116]                             invokeRestart(restart)
[17:29:26.116]                             muffled <- TRUE
[17:29:26.116]                             break
[17:29:26.116]                           }
[17:29:26.116]                         }
[17:29:26.116]                       }
[17:29:26.116]                       invisible(muffled)
[17:29:26.116]                     }
[17:29:26.116]                     muffleCondition(cond, pattern = "^muffle")
[17:29:26.116]                   }
[17:29:26.116]                 }
[17:29:26.116]             }
[17:29:26.116]         }))
[17:29:26.116]     }, error = function(ex) {
[17:29:26.116]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:26.116]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:26.116]                 ...future.rng), started = ...future.startTime, 
[17:29:26.116]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:26.116]             version = "1.8"), class = "FutureResult")
[17:29:26.116]     }, finally = {
[17:29:26.116]         if (!identical(...future.workdir, getwd())) 
[17:29:26.116]             setwd(...future.workdir)
[17:29:26.116]         {
[17:29:26.116]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:26.116]                 ...future.oldOptions$nwarnings <- NULL
[17:29:26.116]             }
[17:29:26.116]             base::options(...future.oldOptions)
[17:29:26.116]             if (.Platform$OS.type == "windows") {
[17:29:26.116]                 old_names <- names(...future.oldEnvVars)
[17:29:26.116]                 envs <- base::Sys.getenv()
[17:29:26.116]                 names <- names(envs)
[17:29:26.116]                 common <- intersect(names, old_names)
[17:29:26.116]                 added <- setdiff(names, old_names)
[17:29:26.116]                 removed <- setdiff(old_names, names)
[17:29:26.116]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:26.116]                   envs[common]]
[17:29:26.116]                 NAMES <- toupper(changed)
[17:29:26.116]                 args <- list()
[17:29:26.116]                 for (kk in seq_along(NAMES)) {
[17:29:26.116]                   name <- changed[[kk]]
[17:29:26.116]                   NAME <- NAMES[[kk]]
[17:29:26.116]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.116]                     next
[17:29:26.116]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:26.116]                 }
[17:29:26.116]                 NAMES <- toupper(added)
[17:29:26.116]                 for (kk in seq_along(NAMES)) {
[17:29:26.116]                   name <- added[[kk]]
[17:29:26.116]                   NAME <- NAMES[[kk]]
[17:29:26.116]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.116]                     next
[17:29:26.116]                   args[[name]] <- ""
[17:29:26.116]                 }
[17:29:26.116]                 NAMES <- toupper(removed)
[17:29:26.116]                 for (kk in seq_along(NAMES)) {
[17:29:26.116]                   name <- removed[[kk]]
[17:29:26.116]                   NAME <- NAMES[[kk]]
[17:29:26.116]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.116]                     next
[17:29:26.116]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:26.116]                 }
[17:29:26.116]                 if (length(args) > 0) 
[17:29:26.116]                   base::do.call(base::Sys.setenv, args = args)
[17:29:26.116]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:26.116]             }
[17:29:26.116]             else {
[17:29:26.116]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:26.116]             }
[17:29:26.116]             {
[17:29:26.116]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:26.116]                   0L) {
[17:29:26.116]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:26.116]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:26.116]                   base::options(opts)
[17:29:26.116]                 }
[17:29:26.116]                 {
[17:29:26.116]                   {
[17:29:26.116]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:26.116]                     NULL
[17:29:26.116]                   }
[17:29:26.116]                   options(future.plan = NULL)
[17:29:26.116]                   if (is.na(NA_character_)) 
[17:29:26.116]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:26.116]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:26.116]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:26.116]                     .init = FALSE)
[17:29:26.116]                 }
[17:29:26.116]             }
[17:29:26.116]         }
[17:29:26.116]     })
[17:29:26.116]     if (TRUE) {
[17:29:26.116]         base::sink(type = "output", split = FALSE)
[17:29:26.116]         if (TRUE) {
[17:29:26.116]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:26.116]         }
[17:29:26.116]         else {
[17:29:26.116]             ...future.result["stdout"] <- base::list(NULL)
[17:29:26.116]         }
[17:29:26.116]         base::close(...future.stdout)
[17:29:26.116]         ...future.stdout <- NULL
[17:29:26.116]     }
[17:29:26.116]     ...future.result$conditions <- ...future.conditions
[17:29:26.116]     ...future.result$finished <- base::Sys.time()
[17:29:26.116]     ...future.result
[17:29:26.116] }
[17:29:26.122] MultisessionFuture started
[17:29:26.122] - Launch lazy future ... done
[17:29:26.122] run() for 'MultisessionFuture' ... done
[17:29:26.123] getGlobalsAndPackages() ...
[17:29:26.123] Searching for globals...
[17:29:26.124] - globals found: [1] '{'
[17:29:26.124] Searching for globals ... DONE
[17:29:26.124] Resolving globals: FALSE
[17:29:26.125] 
[17:29:26.125] 
[17:29:26.125] getGlobalsAndPackages() ... DONE
[17:29:26.130] run() for 'Future' ...
[17:29:26.130] - state: 'created'
[17:29:26.130] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:26.148] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:26.149] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:26.149]   - Field: 'node'
[17:29:26.149]   - Field: 'label'
[17:29:26.150]   - Field: 'local'
[17:29:26.150]   - Field: 'owner'
[17:29:26.150]   - Field: 'envir'
[17:29:26.151]   - Field: 'workers'
[17:29:26.151]   - Field: 'packages'
[17:29:26.151]   - Field: 'gc'
[17:29:26.152]   - Field: 'conditions'
[17:29:26.152]   - Field: 'persistent'
[17:29:26.152]   - Field: 'expr'
[17:29:26.153]   - Field: 'uuid'
[17:29:26.153]   - Field: 'seed'
[17:29:26.153]   - Field: 'version'
[17:29:26.154]   - Field: 'result'
[17:29:26.154]   - Field: 'asynchronous'
[17:29:26.154]   - Field: 'calls'
[17:29:26.155]   - Field: 'globals'
[17:29:26.155]   - Field: 'stdout'
[17:29:26.155]   - Field: 'earlySignal'
[17:29:26.156]   - Field: 'lazy'
[17:29:26.156]   - Field: 'state'
[17:29:26.156] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:26.157] - Launch lazy future ...
[17:29:26.157] Packages needed by the future expression (n = 0): <none>
[17:29:26.158] Packages needed by future strategies (n = 0): <none>
[17:29:26.159] {
[17:29:26.159]     {
[17:29:26.159]         {
[17:29:26.159]             ...future.startTime <- base::Sys.time()
[17:29:26.159]             {
[17:29:26.159]                 {
[17:29:26.159]                   {
[17:29:26.159]                     {
[17:29:26.159]                       base::local({
[17:29:26.159]                         has_future <- base::requireNamespace("future", 
[17:29:26.159]                           quietly = TRUE)
[17:29:26.159]                         if (has_future) {
[17:29:26.159]                           ns <- base::getNamespace("future")
[17:29:26.159]                           version <- ns[[".package"]][["version"]]
[17:29:26.159]                           if (is.null(version)) 
[17:29:26.159]                             version <- utils::packageVersion("future")
[17:29:26.159]                         }
[17:29:26.159]                         else {
[17:29:26.159]                           version <- NULL
[17:29:26.159]                         }
[17:29:26.159]                         if (!has_future || version < "1.8.0") {
[17:29:26.159]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:26.159]                             "", base::R.version$version.string), 
[17:29:26.159]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:26.159]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:26.159]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:26.159]                               "release", "version")], collapse = " "), 
[17:29:26.159]                             hostname = base::Sys.info()[["nodename"]])
[17:29:26.159]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:26.159]                             info)
[17:29:26.159]                           info <- base::paste(info, collapse = "; ")
[17:29:26.159]                           if (!has_future) {
[17:29:26.159]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:26.159]                               info)
[17:29:26.159]                           }
[17:29:26.159]                           else {
[17:29:26.159]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:26.159]                               info, version)
[17:29:26.159]                           }
[17:29:26.159]                           base::stop(msg)
[17:29:26.159]                         }
[17:29:26.159]                       })
[17:29:26.159]                     }
[17:29:26.159]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:26.159]                     base::options(mc.cores = 1L)
[17:29:26.159]                   }
[17:29:26.159]                   ...future.strategy.old <- future::plan("list")
[17:29:26.159]                   options(future.plan = NULL)
[17:29:26.159]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:26.159]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:26.159]                 }
[17:29:26.159]                 ...future.workdir <- getwd()
[17:29:26.159]             }
[17:29:26.159]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:26.159]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:26.159]         }
[17:29:26.159]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:26.159]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:26.159]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:26.159]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:26.159]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:26.159]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:26.159]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:26.159]             base::names(...future.oldOptions))
[17:29:26.159]     }
[17:29:26.159]     if (FALSE) {
[17:29:26.159]     }
[17:29:26.159]     else {
[17:29:26.159]         if (TRUE) {
[17:29:26.159]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:26.159]                 open = "w")
[17:29:26.159]         }
[17:29:26.159]         else {
[17:29:26.159]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:26.159]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:26.159]         }
[17:29:26.159]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:26.159]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:26.159]             base::sink(type = "output", split = FALSE)
[17:29:26.159]             base::close(...future.stdout)
[17:29:26.159]         }, add = TRUE)
[17:29:26.159]     }
[17:29:26.159]     ...future.frame <- base::sys.nframe()
[17:29:26.159]     ...future.conditions <- base::list()
[17:29:26.159]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:26.159]     if (FALSE) {
[17:29:26.159]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:26.159]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:26.159]     }
[17:29:26.159]     ...future.result <- base::tryCatch({
[17:29:26.159]         base::withCallingHandlers({
[17:29:26.159]             ...future.value <- base::withVisible(base::local({
[17:29:26.159]                 ...future.makeSendCondition <- base::local({
[17:29:26.159]                   sendCondition <- NULL
[17:29:26.159]                   function(frame = 1L) {
[17:29:26.159]                     if (is.function(sendCondition)) 
[17:29:26.159]                       return(sendCondition)
[17:29:26.159]                     ns <- getNamespace("parallel")
[17:29:26.159]                     if (exists("sendData", mode = "function", 
[17:29:26.159]                       envir = ns)) {
[17:29:26.159]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:26.159]                         envir = ns)
[17:29:26.159]                       envir <- sys.frame(frame)
[17:29:26.159]                       master <- NULL
[17:29:26.159]                       while (!identical(envir, .GlobalEnv) && 
[17:29:26.159]                         !identical(envir, emptyenv())) {
[17:29:26.159]                         if (exists("master", mode = "list", envir = envir, 
[17:29:26.159]                           inherits = FALSE)) {
[17:29:26.159]                           master <- get("master", mode = "list", 
[17:29:26.159]                             envir = envir, inherits = FALSE)
[17:29:26.159]                           if (inherits(master, c("SOCKnode", 
[17:29:26.159]                             "SOCK0node"))) {
[17:29:26.159]                             sendCondition <<- function(cond) {
[17:29:26.159]                               data <- list(type = "VALUE", value = cond, 
[17:29:26.159]                                 success = TRUE)
[17:29:26.159]                               parallel_sendData(master, data)
[17:29:26.159]                             }
[17:29:26.159]                             return(sendCondition)
[17:29:26.159]                           }
[17:29:26.159]                         }
[17:29:26.159]                         frame <- frame + 1L
[17:29:26.159]                         envir <- sys.frame(frame)
[17:29:26.159]                       }
[17:29:26.159]                     }
[17:29:26.159]                     sendCondition <<- function(cond) NULL
[17:29:26.159]                   }
[17:29:26.159]                 })
[17:29:26.159]                 withCallingHandlers({
[17:29:26.159]                   {
[17:29:26.159]                     2
[17:29:26.159]                   }
[17:29:26.159]                 }, immediateCondition = function(cond) {
[17:29:26.159]                   sendCondition <- ...future.makeSendCondition()
[17:29:26.159]                   sendCondition(cond)
[17:29:26.159]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.159]                   {
[17:29:26.159]                     inherits <- base::inherits
[17:29:26.159]                     invokeRestart <- base::invokeRestart
[17:29:26.159]                     is.null <- base::is.null
[17:29:26.159]                     muffled <- FALSE
[17:29:26.159]                     if (inherits(cond, "message")) {
[17:29:26.159]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:26.159]                       if (muffled) 
[17:29:26.159]                         invokeRestart("muffleMessage")
[17:29:26.159]                     }
[17:29:26.159]                     else if (inherits(cond, "warning")) {
[17:29:26.159]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:26.159]                       if (muffled) 
[17:29:26.159]                         invokeRestart("muffleWarning")
[17:29:26.159]                     }
[17:29:26.159]                     else if (inherits(cond, "condition")) {
[17:29:26.159]                       if (!is.null(pattern)) {
[17:29:26.159]                         computeRestarts <- base::computeRestarts
[17:29:26.159]                         grepl <- base::grepl
[17:29:26.159]                         restarts <- computeRestarts(cond)
[17:29:26.159]                         for (restart in restarts) {
[17:29:26.159]                           name <- restart$name
[17:29:26.159]                           if (is.null(name)) 
[17:29:26.159]                             next
[17:29:26.159]                           if (!grepl(pattern, name)) 
[17:29:26.159]                             next
[17:29:26.159]                           invokeRestart(restart)
[17:29:26.159]                           muffled <- TRUE
[17:29:26.159]                           break
[17:29:26.159]                         }
[17:29:26.159]                       }
[17:29:26.159]                     }
[17:29:26.159]                     invisible(muffled)
[17:29:26.159]                   }
[17:29:26.159]                   muffleCondition(cond)
[17:29:26.159]                 })
[17:29:26.159]             }))
[17:29:26.159]             future::FutureResult(value = ...future.value$value, 
[17:29:26.159]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:26.159]                   ...future.rng), globalenv = if (FALSE) 
[17:29:26.159]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:26.159]                     ...future.globalenv.names))
[17:29:26.159]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:26.159]         }, condition = base::local({
[17:29:26.159]             c <- base::c
[17:29:26.159]             inherits <- base::inherits
[17:29:26.159]             invokeRestart <- base::invokeRestart
[17:29:26.159]             length <- base::length
[17:29:26.159]             list <- base::list
[17:29:26.159]             seq.int <- base::seq.int
[17:29:26.159]             signalCondition <- base::signalCondition
[17:29:26.159]             sys.calls <- base::sys.calls
[17:29:26.159]             `[[` <- base::`[[`
[17:29:26.159]             `+` <- base::`+`
[17:29:26.159]             `<<-` <- base::`<<-`
[17:29:26.159]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:26.159]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:26.159]                   3L)]
[17:29:26.159]             }
[17:29:26.159]             function(cond) {
[17:29:26.159]                 is_error <- inherits(cond, "error")
[17:29:26.159]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:26.159]                   NULL)
[17:29:26.159]                 if (is_error) {
[17:29:26.159]                   sessionInformation <- function() {
[17:29:26.159]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:26.159]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:26.159]                       search = base::search(), system = base::Sys.info())
[17:29:26.159]                   }
[17:29:26.159]                   ...future.conditions[[length(...future.conditions) + 
[17:29:26.159]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:26.159]                     cond$call), session = sessionInformation(), 
[17:29:26.159]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:26.159]                   signalCondition(cond)
[17:29:26.159]                 }
[17:29:26.159]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:26.159]                 "immediateCondition"))) {
[17:29:26.159]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:26.159]                   ...future.conditions[[length(...future.conditions) + 
[17:29:26.159]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:26.159]                   if (TRUE && !signal) {
[17:29:26.159]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.159]                     {
[17:29:26.159]                       inherits <- base::inherits
[17:29:26.159]                       invokeRestart <- base::invokeRestart
[17:29:26.159]                       is.null <- base::is.null
[17:29:26.159]                       muffled <- FALSE
[17:29:26.159]                       if (inherits(cond, "message")) {
[17:29:26.159]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:26.159]                         if (muffled) 
[17:29:26.159]                           invokeRestart("muffleMessage")
[17:29:26.159]                       }
[17:29:26.159]                       else if (inherits(cond, "warning")) {
[17:29:26.159]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:26.159]                         if (muffled) 
[17:29:26.159]                           invokeRestart("muffleWarning")
[17:29:26.159]                       }
[17:29:26.159]                       else if (inherits(cond, "condition")) {
[17:29:26.159]                         if (!is.null(pattern)) {
[17:29:26.159]                           computeRestarts <- base::computeRestarts
[17:29:26.159]                           grepl <- base::grepl
[17:29:26.159]                           restarts <- computeRestarts(cond)
[17:29:26.159]                           for (restart in restarts) {
[17:29:26.159]                             name <- restart$name
[17:29:26.159]                             if (is.null(name)) 
[17:29:26.159]                               next
[17:29:26.159]                             if (!grepl(pattern, name)) 
[17:29:26.159]                               next
[17:29:26.159]                             invokeRestart(restart)
[17:29:26.159]                             muffled <- TRUE
[17:29:26.159]                             break
[17:29:26.159]                           }
[17:29:26.159]                         }
[17:29:26.159]                       }
[17:29:26.159]                       invisible(muffled)
[17:29:26.159]                     }
[17:29:26.159]                     muffleCondition(cond, pattern = "^muffle")
[17:29:26.159]                   }
[17:29:26.159]                 }
[17:29:26.159]                 else {
[17:29:26.159]                   if (TRUE) {
[17:29:26.159]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.159]                     {
[17:29:26.159]                       inherits <- base::inherits
[17:29:26.159]                       invokeRestart <- base::invokeRestart
[17:29:26.159]                       is.null <- base::is.null
[17:29:26.159]                       muffled <- FALSE
[17:29:26.159]                       if (inherits(cond, "message")) {
[17:29:26.159]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:26.159]                         if (muffled) 
[17:29:26.159]                           invokeRestart("muffleMessage")
[17:29:26.159]                       }
[17:29:26.159]                       else if (inherits(cond, "warning")) {
[17:29:26.159]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:26.159]                         if (muffled) 
[17:29:26.159]                           invokeRestart("muffleWarning")
[17:29:26.159]                       }
[17:29:26.159]                       else if (inherits(cond, "condition")) {
[17:29:26.159]                         if (!is.null(pattern)) {
[17:29:26.159]                           computeRestarts <- base::computeRestarts
[17:29:26.159]                           grepl <- base::grepl
[17:29:26.159]                           restarts <- computeRestarts(cond)
[17:29:26.159]                           for (restart in restarts) {
[17:29:26.159]                             name <- restart$name
[17:29:26.159]                             if (is.null(name)) 
[17:29:26.159]                               next
[17:29:26.159]                             if (!grepl(pattern, name)) 
[17:29:26.159]                               next
[17:29:26.159]                             invokeRestart(restart)
[17:29:26.159]                             muffled <- TRUE
[17:29:26.159]                             break
[17:29:26.159]                           }
[17:29:26.159]                         }
[17:29:26.159]                       }
[17:29:26.159]                       invisible(muffled)
[17:29:26.159]                     }
[17:29:26.159]                     muffleCondition(cond, pattern = "^muffle")
[17:29:26.159]                   }
[17:29:26.159]                 }
[17:29:26.159]             }
[17:29:26.159]         }))
[17:29:26.159]     }, error = function(ex) {
[17:29:26.159]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:26.159]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:26.159]                 ...future.rng), started = ...future.startTime, 
[17:29:26.159]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:26.159]             version = "1.8"), class = "FutureResult")
[17:29:26.159]     }, finally = {
[17:29:26.159]         if (!identical(...future.workdir, getwd())) 
[17:29:26.159]             setwd(...future.workdir)
[17:29:26.159]         {
[17:29:26.159]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:26.159]                 ...future.oldOptions$nwarnings <- NULL
[17:29:26.159]             }
[17:29:26.159]             base::options(...future.oldOptions)
[17:29:26.159]             if (.Platform$OS.type == "windows") {
[17:29:26.159]                 old_names <- names(...future.oldEnvVars)
[17:29:26.159]                 envs <- base::Sys.getenv()
[17:29:26.159]                 names <- names(envs)
[17:29:26.159]                 common <- intersect(names, old_names)
[17:29:26.159]                 added <- setdiff(names, old_names)
[17:29:26.159]                 removed <- setdiff(old_names, names)
[17:29:26.159]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:26.159]                   envs[common]]
[17:29:26.159]                 NAMES <- toupper(changed)
[17:29:26.159]                 args <- list()
[17:29:26.159]                 for (kk in seq_along(NAMES)) {
[17:29:26.159]                   name <- changed[[kk]]
[17:29:26.159]                   NAME <- NAMES[[kk]]
[17:29:26.159]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.159]                     next
[17:29:26.159]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:26.159]                 }
[17:29:26.159]                 NAMES <- toupper(added)
[17:29:26.159]                 for (kk in seq_along(NAMES)) {
[17:29:26.159]                   name <- added[[kk]]
[17:29:26.159]                   NAME <- NAMES[[kk]]
[17:29:26.159]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.159]                     next
[17:29:26.159]                   args[[name]] <- ""
[17:29:26.159]                 }
[17:29:26.159]                 NAMES <- toupper(removed)
[17:29:26.159]                 for (kk in seq_along(NAMES)) {
[17:29:26.159]                   name <- removed[[kk]]
[17:29:26.159]                   NAME <- NAMES[[kk]]
[17:29:26.159]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.159]                     next
[17:29:26.159]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:26.159]                 }
[17:29:26.159]                 if (length(args) > 0) 
[17:29:26.159]                   base::do.call(base::Sys.setenv, args = args)
[17:29:26.159]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:26.159]             }
[17:29:26.159]             else {
[17:29:26.159]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:26.159]             }
[17:29:26.159]             {
[17:29:26.159]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:26.159]                   0L) {
[17:29:26.159]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:26.159]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:26.159]                   base::options(opts)
[17:29:26.159]                 }
[17:29:26.159]                 {
[17:29:26.159]                   {
[17:29:26.159]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:26.159]                     NULL
[17:29:26.159]                   }
[17:29:26.159]                   options(future.plan = NULL)
[17:29:26.159]                   if (is.na(NA_character_)) 
[17:29:26.159]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:26.159]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:26.159]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:26.159]                     .init = FALSE)
[17:29:26.159]                 }
[17:29:26.159]             }
[17:29:26.159]         }
[17:29:26.159]     })
[17:29:26.159]     if (TRUE) {
[17:29:26.159]         base::sink(type = "output", split = FALSE)
[17:29:26.159]         if (TRUE) {
[17:29:26.159]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:26.159]         }
[17:29:26.159]         else {
[17:29:26.159]             ...future.result["stdout"] <- base::list(NULL)
[17:29:26.159]         }
[17:29:26.159]         base::close(...future.stdout)
[17:29:26.159]         ...future.stdout <- NULL
[17:29:26.159]     }
[17:29:26.159]     ...future.result$conditions <- ...future.conditions
[17:29:26.159]     ...future.result$finished <- base::Sys.time()
[17:29:26.159]     ...future.result
[17:29:26.159] }
[17:29:26.168] MultisessionFuture started
[17:29:26.168] - Launch lazy future ... done
[17:29:26.168] run() for 'MultisessionFuture' ... done
[17:29:26.170] resolve() on environment ...
[17:29:26.170]  recursive: 0
[17:29:26.170]  elements: [3] 'a'
[17:29:26.171] receiveMessageFromWorker() for ClusterFuture ...
[17:29:26.171] - Validating connection of MultisessionFuture
[17:29:26.171] - received message: FutureResult
[17:29:26.172] - Received FutureResult
[17:29:26.172] - Erased future from FutureRegistry
[17:29:26.172] result() for ClusterFuture ...
[17:29:26.172] - result already collected: FutureResult
[17:29:26.172] result() for ClusterFuture ... done
[17:29:26.172] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:26.173] Future #1
[17:29:26.173]  length: 2 (resolved future 1)
[17:29:26.194] receiveMessageFromWorker() for ClusterFuture ...
[17:29:26.195] - Validating connection of MultisessionFuture
[17:29:26.196] - received message: FutureResult
[17:29:26.196] - Received FutureResult
[17:29:26.196] - Erased future from FutureRegistry
[17:29:26.197] result() for ClusterFuture ...
[17:29:26.197] - result already collected: FutureResult
[17:29:26.197] result() for ClusterFuture ... done
[17:29:26.198] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:26.198] Future #2
[17:29:26.198]  length: 1 (resolved future 2)
[17:29:26.198]  length: 0 (resolved future 3)
[17:29:26.199] resolve() on environment ... DONE
[17:29:26.200] resolve() on environment ...
[17:29:26.200]  recursive: 0
[17:29:26.201]  elements: [3] 'b'
[17:29:26.202] Future #1
[17:29:26.202]  length: 2 (resolved future 1)
[17:29:26.202] Future #2
[17:29:26.202]  length: 1 (resolved future 2)
[17:29:26.203]  length: 0 (resolved future 3)
[17:29:26.203] resolve() on environment ... DONE
[17:29:26.204] resolve() on environment ...
[17:29:26.204]  recursive: 0
[17:29:26.205]  elements: [3] 'c'
[17:29:26.205] Future #1
[17:29:26.206]  length: 2 (resolved future 1)
[17:29:26.206] Future #2
[17:29:26.206]  length: 1 (resolved future 2)
[17:29:26.206]  length: 0 (resolved future 3)
[17:29:26.207] resolve() on environment ... DONE
[17:29:26.208] resolve() on environment ...
[17:29:26.208]  recursive: 0
[17:29:26.209]  elements: [3] 'a', 'b', 'c', '.future_b'
[17:29:26.209] Future #1
[17:29:26.210] result() for ClusterFuture ...
[17:29:26.210] - result already collected: FutureResult
[17:29:26.210] result() for ClusterFuture ... done
[17:29:26.210] result() for ClusterFuture ...
[17:29:26.211] - result already collected: FutureResult
[17:29:26.211] result() for ClusterFuture ... done
[17:29:26.211]  length: 2 (resolved future 1)
[17:29:26.211] Future #2
[17:29:26.212] result() for ClusterFuture ...
[17:29:26.212] - result already collected: FutureResult
[17:29:26.212] result() for ClusterFuture ... done
[17:29:26.213] result() for ClusterFuture ...
[17:29:26.213] - result already collected: FutureResult
[17:29:26.213] result() for ClusterFuture ... done
[17:29:26.213]  length: 1 (resolved future 2)
[17:29:26.214]  length: 0 (resolved future 3)
[17:29:26.214] resolve() on environment ... DONE
[17:29:26.215] resolve() on environment ...
[17:29:26.215]  recursive: 99
[17:29:26.216]  elements: [3] '.future_b', 'a', 'b', 'c'
[17:29:26.216] Future #1
[17:29:26.217] result() for ClusterFuture ...
[17:29:26.217] - result already collected: FutureResult
[17:29:26.217] result() for ClusterFuture ... done
[17:29:26.217] result() for ClusterFuture ...
[17:29:26.218] - result already collected: FutureResult
[17:29:26.218] result() for ClusterFuture ... done
[17:29:26.218] A MultisessionFuture was resolved
[17:29:26.219]  length: 2 (resolved future 1)
[17:29:26.219] Future #2
[17:29:26.219] result() for ClusterFuture ...
[17:29:26.219] - result already collected: FutureResult
[17:29:26.220] result() for ClusterFuture ... done
[17:29:26.220] result() for ClusterFuture ...
[17:29:26.220] - result already collected: FutureResult
[17:29:26.220] result() for ClusterFuture ... done
[17:29:26.221] A MultisessionFuture was resolved
[17:29:26.221]  length: 1 (resolved future 2)
[17:29:26.221]  length: 0 (resolved future 3)
[17:29:26.222] resolve() on environment ... DONE
*** resolve() for environments ... DONE
*** resolve() for list environments ...
[17:29:26.223] resolve() on list environment ...
[17:29:26.223]  recursive: 0
[17:29:26.224]  length: 2
[17:29:26.225]  elements: 'a', 'b'
[17:29:26.225]  length: 1 (resolved future 1)
[17:29:26.225]  length: 0 (resolved future 2)
[17:29:26.225] resolve() on list environment ... DONE
[17:29:26.226] getGlobalsAndPackages() ...
[17:29:26.226] Searching for globals...
[17:29:26.227] 
[17:29:26.227] Searching for globals ... DONE
[17:29:26.227] - globals: [0] <none>
[17:29:26.228] getGlobalsAndPackages() ... DONE
[17:29:26.228] run() for 'Future' ...
[17:29:26.229] - state: 'created'
[17:29:26.229] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:26.249] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:26.249] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:26.250]   - Field: 'node'
[17:29:26.250]   - Field: 'label'
[17:29:26.250]   - Field: 'local'
[17:29:26.250]   - Field: 'owner'
[17:29:26.251]   - Field: 'envir'
[17:29:26.251]   - Field: 'workers'
[17:29:26.251]   - Field: 'packages'
[17:29:26.252]   - Field: 'gc'
[17:29:26.252]   - Field: 'conditions'
[17:29:26.252]   - Field: 'persistent'
[17:29:26.252]   - Field: 'expr'
[17:29:26.253]   - Field: 'uuid'
[17:29:26.253]   - Field: 'seed'
[17:29:26.254]   - Field: 'version'
[17:29:26.254]   - Field: 'result'
[17:29:26.254]   - Field: 'asynchronous'
[17:29:26.254]   - Field: 'calls'
[17:29:26.255]   - Field: 'globals'
[17:29:26.255]   - Field: 'stdout'
[17:29:26.255]   - Field: 'earlySignal'
[17:29:26.255]   - Field: 'lazy'
[17:29:26.255]   - Field: 'state'
[17:29:26.255] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:26.256] - Launch lazy future ...
[17:29:26.256] Packages needed by the future expression (n = 0): <none>
[17:29:26.256] Packages needed by future strategies (n = 0): <none>
[17:29:26.257] {
[17:29:26.257]     {
[17:29:26.257]         {
[17:29:26.257]             ...future.startTime <- base::Sys.time()
[17:29:26.257]             {
[17:29:26.257]                 {
[17:29:26.257]                   {
[17:29:26.257]                     {
[17:29:26.257]                       base::local({
[17:29:26.257]                         has_future <- base::requireNamespace("future", 
[17:29:26.257]                           quietly = TRUE)
[17:29:26.257]                         if (has_future) {
[17:29:26.257]                           ns <- base::getNamespace("future")
[17:29:26.257]                           version <- ns[[".package"]][["version"]]
[17:29:26.257]                           if (is.null(version)) 
[17:29:26.257]                             version <- utils::packageVersion("future")
[17:29:26.257]                         }
[17:29:26.257]                         else {
[17:29:26.257]                           version <- NULL
[17:29:26.257]                         }
[17:29:26.257]                         if (!has_future || version < "1.8.0") {
[17:29:26.257]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:26.257]                             "", base::R.version$version.string), 
[17:29:26.257]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:26.257]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:26.257]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:26.257]                               "release", "version")], collapse = " "), 
[17:29:26.257]                             hostname = base::Sys.info()[["nodename"]])
[17:29:26.257]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:26.257]                             info)
[17:29:26.257]                           info <- base::paste(info, collapse = "; ")
[17:29:26.257]                           if (!has_future) {
[17:29:26.257]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:26.257]                               info)
[17:29:26.257]                           }
[17:29:26.257]                           else {
[17:29:26.257]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:26.257]                               info, version)
[17:29:26.257]                           }
[17:29:26.257]                           base::stop(msg)
[17:29:26.257]                         }
[17:29:26.257]                       })
[17:29:26.257]                     }
[17:29:26.257]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:26.257]                     base::options(mc.cores = 1L)
[17:29:26.257]                   }
[17:29:26.257]                   ...future.strategy.old <- future::plan("list")
[17:29:26.257]                   options(future.plan = NULL)
[17:29:26.257]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:26.257]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:26.257]                 }
[17:29:26.257]                 ...future.workdir <- getwd()
[17:29:26.257]             }
[17:29:26.257]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:26.257]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:26.257]         }
[17:29:26.257]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:26.257]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:26.257]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:26.257]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:26.257]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:26.257]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:26.257]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:26.257]             base::names(...future.oldOptions))
[17:29:26.257]     }
[17:29:26.257]     if (FALSE) {
[17:29:26.257]     }
[17:29:26.257]     else {
[17:29:26.257]         if (TRUE) {
[17:29:26.257]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:26.257]                 open = "w")
[17:29:26.257]         }
[17:29:26.257]         else {
[17:29:26.257]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:26.257]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:26.257]         }
[17:29:26.257]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:26.257]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:26.257]             base::sink(type = "output", split = FALSE)
[17:29:26.257]             base::close(...future.stdout)
[17:29:26.257]         }, add = TRUE)
[17:29:26.257]     }
[17:29:26.257]     ...future.frame <- base::sys.nframe()
[17:29:26.257]     ...future.conditions <- base::list()
[17:29:26.257]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:26.257]     if (FALSE) {
[17:29:26.257]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:26.257]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:26.257]     }
[17:29:26.257]     ...future.result <- base::tryCatch({
[17:29:26.257]         base::withCallingHandlers({
[17:29:26.257]             ...future.value <- base::withVisible(base::local({
[17:29:26.257]                 ...future.makeSendCondition <- base::local({
[17:29:26.257]                   sendCondition <- NULL
[17:29:26.257]                   function(frame = 1L) {
[17:29:26.257]                     if (is.function(sendCondition)) 
[17:29:26.257]                       return(sendCondition)
[17:29:26.257]                     ns <- getNamespace("parallel")
[17:29:26.257]                     if (exists("sendData", mode = "function", 
[17:29:26.257]                       envir = ns)) {
[17:29:26.257]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:26.257]                         envir = ns)
[17:29:26.257]                       envir <- sys.frame(frame)
[17:29:26.257]                       master <- NULL
[17:29:26.257]                       while (!identical(envir, .GlobalEnv) && 
[17:29:26.257]                         !identical(envir, emptyenv())) {
[17:29:26.257]                         if (exists("master", mode = "list", envir = envir, 
[17:29:26.257]                           inherits = FALSE)) {
[17:29:26.257]                           master <- get("master", mode = "list", 
[17:29:26.257]                             envir = envir, inherits = FALSE)
[17:29:26.257]                           if (inherits(master, c("SOCKnode", 
[17:29:26.257]                             "SOCK0node"))) {
[17:29:26.257]                             sendCondition <<- function(cond) {
[17:29:26.257]                               data <- list(type = "VALUE", value = cond, 
[17:29:26.257]                                 success = TRUE)
[17:29:26.257]                               parallel_sendData(master, data)
[17:29:26.257]                             }
[17:29:26.257]                             return(sendCondition)
[17:29:26.257]                           }
[17:29:26.257]                         }
[17:29:26.257]                         frame <- frame + 1L
[17:29:26.257]                         envir <- sys.frame(frame)
[17:29:26.257]                       }
[17:29:26.257]                     }
[17:29:26.257]                     sendCondition <<- function(cond) NULL
[17:29:26.257]                   }
[17:29:26.257]                 })
[17:29:26.257]                 withCallingHandlers({
[17:29:26.257]                   1
[17:29:26.257]                 }, immediateCondition = function(cond) {
[17:29:26.257]                   sendCondition <- ...future.makeSendCondition()
[17:29:26.257]                   sendCondition(cond)
[17:29:26.257]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.257]                   {
[17:29:26.257]                     inherits <- base::inherits
[17:29:26.257]                     invokeRestart <- base::invokeRestart
[17:29:26.257]                     is.null <- base::is.null
[17:29:26.257]                     muffled <- FALSE
[17:29:26.257]                     if (inherits(cond, "message")) {
[17:29:26.257]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:26.257]                       if (muffled) 
[17:29:26.257]                         invokeRestart("muffleMessage")
[17:29:26.257]                     }
[17:29:26.257]                     else if (inherits(cond, "warning")) {
[17:29:26.257]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:26.257]                       if (muffled) 
[17:29:26.257]                         invokeRestart("muffleWarning")
[17:29:26.257]                     }
[17:29:26.257]                     else if (inherits(cond, "condition")) {
[17:29:26.257]                       if (!is.null(pattern)) {
[17:29:26.257]                         computeRestarts <- base::computeRestarts
[17:29:26.257]                         grepl <- base::grepl
[17:29:26.257]                         restarts <- computeRestarts(cond)
[17:29:26.257]                         for (restart in restarts) {
[17:29:26.257]                           name <- restart$name
[17:29:26.257]                           if (is.null(name)) 
[17:29:26.257]                             next
[17:29:26.257]                           if (!grepl(pattern, name)) 
[17:29:26.257]                             next
[17:29:26.257]                           invokeRestart(restart)
[17:29:26.257]                           muffled <- TRUE
[17:29:26.257]                           break
[17:29:26.257]                         }
[17:29:26.257]                       }
[17:29:26.257]                     }
[17:29:26.257]                     invisible(muffled)
[17:29:26.257]                   }
[17:29:26.257]                   muffleCondition(cond)
[17:29:26.257]                 })
[17:29:26.257]             }))
[17:29:26.257]             future::FutureResult(value = ...future.value$value, 
[17:29:26.257]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:26.257]                   ...future.rng), globalenv = if (FALSE) 
[17:29:26.257]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:26.257]                     ...future.globalenv.names))
[17:29:26.257]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:26.257]         }, condition = base::local({
[17:29:26.257]             c <- base::c
[17:29:26.257]             inherits <- base::inherits
[17:29:26.257]             invokeRestart <- base::invokeRestart
[17:29:26.257]             length <- base::length
[17:29:26.257]             list <- base::list
[17:29:26.257]             seq.int <- base::seq.int
[17:29:26.257]             signalCondition <- base::signalCondition
[17:29:26.257]             sys.calls <- base::sys.calls
[17:29:26.257]             `[[` <- base::`[[`
[17:29:26.257]             `+` <- base::`+`
[17:29:26.257]             `<<-` <- base::`<<-`
[17:29:26.257]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:26.257]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:26.257]                   3L)]
[17:29:26.257]             }
[17:29:26.257]             function(cond) {
[17:29:26.257]                 is_error <- inherits(cond, "error")
[17:29:26.257]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:26.257]                   NULL)
[17:29:26.257]                 if (is_error) {
[17:29:26.257]                   sessionInformation <- function() {
[17:29:26.257]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:26.257]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:26.257]                       search = base::search(), system = base::Sys.info())
[17:29:26.257]                   }
[17:29:26.257]                   ...future.conditions[[length(...future.conditions) + 
[17:29:26.257]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:26.257]                     cond$call), session = sessionInformation(), 
[17:29:26.257]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:26.257]                   signalCondition(cond)
[17:29:26.257]                 }
[17:29:26.257]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:26.257]                 "immediateCondition"))) {
[17:29:26.257]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:26.257]                   ...future.conditions[[length(...future.conditions) + 
[17:29:26.257]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:26.257]                   if (TRUE && !signal) {
[17:29:26.257]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.257]                     {
[17:29:26.257]                       inherits <- base::inherits
[17:29:26.257]                       invokeRestart <- base::invokeRestart
[17:29:26.257]                       is.null <- base::is.null
[17:29:26.257]                       muffled <- FALSE
[17:29:26.257]                       if (inherits(cond, "message")) {
[17:29:26.257]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:26.257]                         if (muffled) 
[17:29:26.257]                           invokeRestart("muffleMessage")
[17:29:26.257]                       }
[17:29:26.257]                       else if (inherits(cond, "warning")) {
[17:29:26.257]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:26.257]                         if (muffled) 
[17:29:26.257]                           invokeRestart("muffleWarning")
[17:29:26.257]                       }
[17:29:26.257]                       else if (inherits(cond, "condition")) {
[17:29:26.257]                         if (!is.null(pattern)) {
[17:29:26.257]                           computeRestarts <- base::computeRestarts
[17:29:26.257]                           grepl <- base::grepl
[17:29:26.257]                           restarts <- computeRestarts(cond)
[17:29:26.257]                           for (restart in restarts) {
[17:29:26.257]                             name <- restart$name
[17:29:26.257]                             if (is.null(name)) 
[17:29:26.257]                               next
[17:29:26.257]                             if (!grepl(pattern, name)) 
[17:29:26.257]                               next
[17:29:26.257]                             invokeRestart(restart)
[17:29:26.257]                             muffled <- TRUE
[17:29:26.257]                             break
[17:29:26.257]                           }
[17:29:26.257]                         }
[17:29:26.257]                       }
[17:29:26.257]                       invisible(muffled)
[17:29:26.257]                     }
[17:29:26.257]                     muffleCondition(cond, pattern = "^muffle")
[17:29:26.257]                   }
[17:29:26.257]                 }
[17:29:26.257]                 else {
[17:29:26.257]                   if (TRUE) {
[17:29:26.257]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.257]                     {
[17:29:26.257]                       inherits <- base::inherits
[17:29:26.257]                       invokeRestart <- base::invokeRestart
[17:29:26.257]                       is.null <- base::is.null
[17:29:26.257]                       muffled <- FALSE
[17:29:26.257]                       if (inherits(cond, "message")) {
[17:29:26.257]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:26.257]                         if (muffled) 
[17:29:26.257]                           invokeRestart("muffleMessage")
[17:29:26.257]                       }
[17:29:26.257]                       else if (inherits(cond, "warning")) {
[17:29:26.257]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:26.257]                         if (muffled) 
[17:29:26.257]                           invokeRestart("muffleWarning")
[17:29:26.257]                       }
[17:29:26.257]                       else if (inherits(cond, "condition")) {
[17:29:26.257]                         if (!is.null(pattern)) {
[17:29:26.257]                           computeRestarts <- base::computeRestarts
[17:29:26.257]                           grepl <- base::grepl
[17:29:26.257]                           restarts <- computeRestarts(cond)
[17:29:26.257]                           for (restart in restarts) {
[17:29:26.257]                             name <- restart$name
[17:29:26.257]                             if (is.null(name)) 
[17:29:26.257]                               next
[17:29:26.257]                             if (!grepl(pattern, name)) 
[17:29:26.257]                               next
[17:29:26.257]                             invokeRestart(restart)
[17:29:26.257]                             muffled <- TRUE
[17:29:26.257]                             break
[17:29:26.257]                           }
[17:29:26.257]                         }
[17:29:26.257]                       }
[17:29:26.257]                       invisible(muffled)
[17:29:26.257]                     }
[17:29:26.257]                     muffleCondition(cond, pattern = "^muffle")
[17:29:26.257]                   }
[17:29:26.257]                 }
[17:29:26.257]             }
[17:29:26.257]         }))
[17:29:26.257]     }, error = function(ex) {
[17:29:26.257]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:26.257]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:26.257]                 ...future.rng), started = ...future.startTime, 
[17:29:26.257]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:26.257]             version = "1.8"), class = "FutureResult")
[17:29:26.257]     }, finally = {
[17:29:26.257]         if (!identical(...future.workdir, getwd())) 
[17:29:26.257]             setwd(...future.workdir)
[17:29:26.257]         {
[17:29:26.257]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:26.257]                 ...future.oldOptions$nwarnings <- NULL
[17:29:26.257]             }
[17:29:26.257]             base::options(...future.oldOptions)
[17:29:26.257]             if (.Platform$OS.type == "windows") {
[17:29:26.257]                 old_names <- names(...future.oldEnvVars)
[17:29:26.257]                 envs <- base::Sys.getenv()
[17:29:26.257]                 names <- names(envs)
[17:29:26.257]                 common <- intersect(names, old_names)
[17:29:26.257]                 added <- setdiff(names, old_names)
[17:29:26.257]                 removed <- setdiff(old_names, names)
[17:29:26.257]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:26.257]                   envs[common]]
[17:29:26.257]                 NAMES <- toupper(changed)
[17:29:26.257]                 args <- list()
[17:29:26.257]                 for (kk in seq_along(NAMES)) {
[17:29:26.257]                   name <- changed[[kk]]
[17:29:26.257]                   NAME <- NAMES[[kk]]
[17:29:26.257]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.257]                     next
[17:29:26.257]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:26.257]                 }
[17:29:26.257]                 NAMES <- toupper(added)
[17:29:26.257]                 for (kk in seq_along(NAMES)) {
[17:29:26.257]                   name <- added[[kk]]
[17:29:26.257]                   NAME <- NAMES[[kk]]
[17:29:26.257]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.257]                     next
[17:29:26.257]                   args[[name]] <- ""
[17:29:26.257]                 }
[17:29:26.257]                 NAMES <- toupper(removed)
[17:29:26.257]                 for (kk in seq_along(NAMES)) {
[17:29:26.257]                   name <- removed[[kk]]
[17:29:26.257]                   NAME <- NAMES[[kk]]
[17:29:26.257]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.257]                     next
[17:29:26.257]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:26.257]                 }
[17:29:26.257]                 if (length(args) > 0) 
[17:29:26.257]                   base::do.call(base::Sys.setenv, args = args)
[17:29:26.257]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:26.257]             }
[17:29:26.257]             else {
[17:29:26.257]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:26.257]             }
[17:29:26.257]             {
[17:29:26.257]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:26.257]                   0L) {
[17:29:26.257]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:26.257]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:26.257]                   base::options(opts)
[17:29:26.257]                 }
[17:29:26.257]                 {
[17:29:26.257]                   {
[17:29:26.257]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:26.257]                     NULL
[17:29:26.257]                   }
[17:29:26.257]                   options(future.plan = NULL)
[17:29:26.257]                   if (is.na(NA_character_)) 
[17:29:26.257]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:26.257]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:26.257]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:26.257]                     .init = FALSE)
[17:29:26.257]                 }
[17:29:26.257]             }
[17:29:26.257]         }
[17:29:26.257]     })
[17:29:26.257]     if (TRUE) {
[17:29:26.257]         base::sink(type = "output", split = FALSE)
[17:29:26.257]         if (TRUE) {
[17:29:26.257]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:26.257]         }
[17:29:26.257]         else {
[17:29:26.257]             ...future.result["stdout"] <- base::list(NULL)
[17:29:26.257]         }
[17:29:26.257]         base::close(...future.stdout)
[17:29:26.257]         ...future.stdout <- NULL
[17:29:26.257]     }
[17:29:26.257]     ...future.result$conditions <- ...future.conditions
[17:29:26.257]     ...future.result$finished <- base::Sys.time()
[17:29:26.257]     ...future.result
[17:29:26.257] }
[17:29:26.264] MultisessionFuture started
[17:29:26.265] - Launch lazy future ... done
[17:29:26.265] run() for 'MultisessionFuture' ... done
[17:29:26.265] getGlobalsAndPackages() ...
[17:29:26.266] Searching for globals...
[17:29:26.267] 
[17:29:26.267] Searching for globals ... DONE
[17:29:26.267] - globals: [0] <none>
[17:29:26.267] getGlobalsAndPackages() ... DONE
[17:29:26.268] run() for 'Future' ...
[17:29:26.268] - state: 'created'
[17:29:26.269] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:26.288] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:26.288] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:26.289]   - Field: 'node'
[17:29:26.289]   - Field: 'label'
[17:29:26.289]   - Field: 'local'
[17:29:26.289]   - Field: 'owner'
[17:29:26.289]   - Field: 'envir'
[17:29:26.290]   - Field: 'workers'
[17:29:26.290]   - Field: 'packages'
[17:29:26.290]   - Field: 'gc'
[17:29:26.290]   - Field: 'conditions'
[17:29:26.290]   - Field: 'persistent'
[17:29:26.290]   - Field: 'expr'
[17:29:26.291]   - Field: 'uuid'
[17:29:26.291]   - Field: 'seed'
[17:29:26.291]   - Field: 'version'
[17:29:26.291]   - Field: 'result'
[17:29:26.291]   - Field: 'asynchronous'
[17:29:26.292]   - Field: 'calls'
[17:29:26.292]   - Field: 'globals'
[17:29:26.292]   - Field: 'stdout'
[17:29:26.292]   - Field: 'earlySignal'
[17:29:26.292]   - Field: 'lazy'
[17:29:26.292]   - Field: 'state'
[17:29:26.293] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:26.293] - Launch lazy future ...
[17:29:26.293] Packages needed by the future expression (n = 0): <none>
[17:29:26.293] Packages needed by future strategies (n = 0): <none>
[17:29:26.294] {
[17:29:26.294]     {
[17:29:26.294]         {
[17:29:26.294]             ...future.startTime <- base::Sys.time()
[17:29:26.294]             {
[17:29:26.294]                 {
[17:29:26.294]                   {
[17:29:26.294]                     {
[17:29:26.294]                       base::local({
[17:29:26.294]                         has_future <- base::requireNamespace("future", 
[17:29:26.294]                           quietly = TRUE)
[17:29:26.294]                         if (has_future) {
[17:29:26.294]                           ns <- base::getNamespace("future")
[17:29:26.294]                           version <- ns[[".package"]][["version"]]
[17:29:26.294]                           if (is.null(version)) 
[17:29:26.294]                             version <- utils::packageVersion("future")
[17:29:26.294]                         }
[17:29:26.294]                         else {
[17:29:26.294]                           version <- NULL
[17:29:26.294]                         }
[17:29:26.294]                         if (!has_future || version < "1.8.0") {
[17:29:26.294]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:26.294]                             "", base::R.version$version.string), 
[17:29:26.294]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:26.294]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:26.294]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:26.294]                               "release", "version")], collapse = " "), 
[17:29:26.294]                             hostname = base::Sys.info()[["nodename"]])
[17:29:26.294]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:26.294]                             info)
[17:29:26.294]                           info <- base::paste(info, collapse = "; ")
[17:29:26.294]                           if (!has_future) {
[17:29:26.294]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:26.294]                               info)
[17:29:26.294]                           }
[17:29:26.294]                           else {
[17:29:26.294]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:26.294]                               info, version)
[17:29:26.294]                           }
[17:29:26.294]                           base::stop(msg)
[17:29:26.294]                         }
[17:29:26.294]                       })
[17:29:26.294]                     }
[17:29:26.294]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:26.294]                     base::options(mc.cores = 1L)
[17:29:26.294]                   }
[17:29:26.294]                   ...future.strategy.old <- future::plan("list")
[17:29:26.294]                   options(future.plan = NULL)
[17:29:26.294]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:26.294]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:26.294]                 }
[17:29:26.294]                 ...future.workdir <- getwd()
[17:29:26.294]             }
[17:29:26.294]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:26.294]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:26.294]         }
[17:29:26.294]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:26.294]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:26.294]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:26.294]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:26.294]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:26.294]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:26.294]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:26.294]             base::names(...future.oldOptions))
[17:29:26.294]     }
[17:29:26.294]     if (FALSE) {
[17:29:26.294]     }
[17:29:26.294]     else {
[17:29:26.294]         if (TRUE) {
[17:29:26.294]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:26.294]                 open = "w")
[17:29:26.294]         }
[17:29:26.294]         else {
[17:29:26.294]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:26.294]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:26.294]         }
[17:29:26.294]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:26.294]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:26.294]             base::sink(type = "output", split = FALSE)
[17:29:26.294]             base::close(...future.stdout)
[17:29:26.294]         }, add = TRUE)
[17:29:26.294]     }
[17:29:26.294]     ...future.frame <- base::sys.nframe()
[17:29:26.294]     ...future.conditions <- base::list()
[17:29:26.294]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:26.294]     if (FALSE) {
[17:29:26.294]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:26.294]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:26.294]     }
[17:29:26.294]     ...future.result <- base::tryCatch({
[17:29:26.294]         base::withCallingHandlers({
[17:29:26.294]             ...future.value <- base::withVisible(base::local({
[17:29:26.294]                 ...future.makeSendCondition <- base::local({
[17:29:26.294]                   sendCondition <- NULL
[17:29:26.294]                   function(frame = 1L) {
[17:29:26.294]                     if (is.function(sendCondition)) 
[17:29:26.294]                       return(sendCondition)
[17:29:26.294]                     ns <- getNamespace("parallel")
[17:29:26.294]                     if (exists("sendData", mode = "function", 
[17:29:26.294]                       envir = ns)) {
[17:29:26.294]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:26.294]                         envir = ns)
[17:29:26.294]                       envir <- sys.frame(frame)
[17:29:26.294]                       master <- NULL
[17:29:26.294]                       while (!identical(envir, .GlobalEnv) && 
[17:29:26.294]                         !identical(envir, emptyenv())) {
[17:29:26.294]                         if (exists("master", mode = "list", envir = envir, 
[17:29:26.294]                           inherits = FALSE)) {
[17:29:26.294]                           master <- get("master", mode = "list", 
[17:29:26.294]                             envir = envir, inherits = FALSE)
[17:29:26.294]                           if (inherits(master, c("SOCKnode", 
[17:29:26.294]                             "SOCK0node"))) {
[17:29:26.294]                             sendCondition <<- function(cond) {
[17:29:26.294]                               data <- list(type = "VALUE", value = cond, 
[17:29:26.294]                                 success = TRUE)
[17:29:26.294]                               parallel_sendData(master, data)
[17:29:26.294]                             }
[17:29:26.294]                             return(sendCondition)
[17:29:26.294]                           }
[17:29:26.294]                         }
[17:29:26.294]                         frame <- frame + 1L
[17:29:26.294]                         envir <- sys.frame(frame)
[17:29:26.294]                       }
[17:29:26.294]                     }
[17:29:26.294]                     sendCondition <<- function(cond) NULL
[17:29:26.294]                   }
[17:29:26.294]                 })
[17:29:26.294]                 withCallingHandlers({
[17:29:26.294]                   2
[17:29:26.294]                 }, immediateCondition = function(cond) {
[17:29:26.294]                   sendCondition <- ...future.makeSendCondition()
[17:29:26.294]                   sendCondition(cond)
[17:29:26.294]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.294]                   {
[17:29:26.294]                     inherits <- base::inherits
[17:29:26.294]                     invokeRestart <- base::invokeRestart
[17:29:26.294]                     is.null <- base::is.null
[17:29:26.294]                     muffled <- FALSE
[17:29:26.294]                     if (inherits(cond, "message")) {
[17:29:26.294]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:26.294]                       if (muffled) 
[17:29:26.294]                         invokeRestart("muffleMessage")
[17:29:26.294]                     }
[17:29:26.294]                     else if (inherits(cond, "warning")) {
[17:29:26.294]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:26.294]                       if (muffled) 
[17:29:26.294]                         invokeRestart("muffleWarning")
[17:29:26.294]                     }
[17:29:26.294]                     else if (inherits(cond, "condition")) {
[17:29:26.294]                       if (!is.null(pattern)) {
[17:29:26.294]                         computeRestarts <- base::computeRestarts
[17:29:26.294]                         grepl <- base::grepl
[17:29:26.294]                         restarts <- computeRestarts(cond)
[17:29:26.294]                         for (restart in restarts) {
[17:29:26.294]                           name <- restart$name
[17:29:26.294]                           if (is.null(name)) 
[17:29:26.294]                             next
[17:29:26.294]                           if (!grepl(pattern, name)) 
[17:29:26.294]                             next
[17:29:26.294]                           invokeRestart(restart)
[17:29:26.294]                           muffled <- TRUE
[17:29:26.294]                           break
[17:29:26.294]                         }
[17:29:26.294]                       }
[17:29:26.294]                     }
[17:29:26.294]                     invisible(muffled)
[17:29:26.294]                   }
[17:29:26.294]                   muffleCondition(cond)
[17:29:26.294]                 })
[17:29:26.294]             }))
[17:29:26.294]             future::FutureResult(value = ...future.value$value, 
[17:29:26.294]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:26.294]                   ...future.rng), globalenv = if (FALSE) 
[17:29:26.294]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:26.294]                     ...future.globalenv.names))
[17:29:26.294]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:26.294]         }, condition = base::local({
[17:29:26.294]             c <- base::c
[17:29:26.294]             inherits <- base::inherits
[17:29:26.294]             invokeRestart <- base::invokeRestart
[17:29:26.294]             length <- base::length
[17:29:26.294]             list <- base::list
[17:29:26.294]             seq.int <- base::seq.int
[17:29:26.294]             signalCondition <- base::signalCondition
[17:29:26.294]             sys.calls <- base::sys.calls
[17:29:26.294]             `[[` <- base::`[[`
[17:29:26.294]             `+` <- base::`+`
[17:29:26.294]             `<<-` <- base::`<<-`
[17:29:26.294]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:26.294]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:26.294]                   3L)]
[17:29:26.294]             }
[17:29:26.294]             function(cond) {
[17:29:26.294]                 is_error <- inherits(cond, "error")
[17:29:26.294]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:26.294]                   NULL)
[17:29:26.294]                 if (is_error) {
[17:29:26.294]                   sessionInformation <- function() {
[17:29:26.294]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:26.294]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:26.294]                       search = base::search(), system = base::Sys.info())
[17:29:26.294]                   }
[17:29:26.294]                   ...future.conditions[[length(...future.conditions) + 
[17:29:26.294]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:26.294]                     cond$call), session = sessionInformation(), 
[17:29:26.294]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:26.294]                   signalCondition(cond)
[17:29:26.294]                 }
[17:29:26.294]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:26.294]                 "immediateCondition"))) {
[17:29:26.294]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:26.294]                   ...future.conditions[[length(...future.conditions) + 
[17:29:26.294]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:26.294]                   if (TRUE && !signal) {
[17:29:26.294]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.294]                     {
[17:29:26.294]                       inherits <- base::inherits
[17:29:26.294]                       invokeRestart <- base::invokeRestart
[17:29:26.294]                       is.null <- base::is.null
[17:29:26.294]                       muffled <- FALSE
[17:29:26.294]                       if (inherits(cond, "message")) {
[17:29:26.294]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:26.294]                         if (muffled) 
[17:29:26.294]                           invokeRestart("muffleMessage")
[17:29:26.294]                       }
[17:29:26.294]                       else if (inherits(cond, "warning")) {
[17:29:26.294]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:26.294]                         if (muffled) 
[17:29:26.294]                           invokeRestart("muffleWarning")
[17:29:26.294]                       }
[17:29:26.294]                       else if (inherits(cond, "condition")) {
[17:29:26.294]                         if (!is.null(pattern)) {
[17:29:26.294]                           computeRestarts <- base::computeRestarts
[17:29:26.294]                           grepl <- base::grepl
[17:29:26.294]                           restarts <- computeRestarts(cond)
[17:29:26.294]                           for (restart in restarts) {
[17:29:26.294]                             name <- restart$name
[17:29:26.294]                             if (is.null(name)) 
[17:29:26.294]                               next
[17:29:26.294]                             if (!grepl(pattern, name)) 
[17:29:26.294]                               next
[17:29:26.294]                             invokeRestart(restart)
[17:29:26.294]                             muffled <- TRUE
[17:29:26.294]                             break
[17:29:26.294]                           }
[17:29:26.294]                         }
[17:29:26.294]                       }
[17:29:26.294]                       invisible(muffled)
[17:29:26.294]                     }
[17:29:26.294]                     muffleCondition(cond, pattern = "^muffle")
[17:29:26.294]                   }
[17:29:26.294]                 }
[17:29:26.294]                 else {
[17:29:26.294]                   if (TRUE) {
[17:29:26.294]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.294]                     {
[17:29:26.294]                       inherits <- base::inherits
[17:29:26.294]                       invokeRestart <- base::invokeRestart
[17:29:26.294]                       is.null <- base::is.null
[17:29:26.294]                       muffled <- FALSE
[17:29:26.294]                       if (inherits(cond, "message")) {
[17:29:26.294]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:26.294]                         if (muffled) 
[17:29:26.294]                           invokeRestart("muffleMessage")
[17:29:26.294]                       }
[17:29:26.294]                       else if (inherits(cond, "warning")) {
[17:29:26.294]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:26.294]                         if (muffled) 
[17:29:26.294]                           invokeRestart("muffleWarning")
[17:29:26.294]                       }
[17:29:26.294]                       else if (inherits(cond, "condition")) {
[17:29:26.294]                         if (!is.null(pattern)) {
[17:29:26.294]                           computeRestarts <- base::computeRestarts
[17:29:26.294]                           grepl <- base::grepl
[17:29:26.294]                           restarts <- computeRestarts(cond)
[17:29:26.294]                           for (restart in restarts) {
[17:29:26.294]                             name <- restart$name
[17:29:26.294]                             if (is.null(name)) 
[17:29:26.294]                               next
[17:29:26.294]                             if (!grepl(pattern, name)) 
[17:29:26.294]                               next
[17:29:26.294]                             invokeRestart(restart)
[17:29:26.294]                             muffled <- TRUE
[17:29:26.294]                             break
[17:29:26.294]                           }
[17:29:26.294]                         }
[17:29:26.294]                       }
[17:29:26.294]                       invisible(muffled)
[17:29:26.294]                     }
[17:29:26.294]                     muffleCondition(cond, pattern = "^muffle")
[17:29:26.294]                   }
[17:29:26.294]                 }
[17:29:26.294]             }
[17:29:26.294]         }))
[17:29:26.294]     }, error = function(ex) {
[17:29:26.294]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:26.294]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:26.294]                 ...future.rng), started = ...future.startTime, 
[17:29:26.294]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:26.294]             version = "1.8"), class = "FutureResult")
[17:29:26.294]     }, finally = {
[17:29:26.294]         if (!identical(...future.workdir, getwd())) 
[17:29:26.294]             setwd(...future.workdir)
[17:29:26.294]         {
[17:29:26.294]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:26.294]                 ...future.oldOptions$nwarnings <- NULL
[17:29:26.294]             }
[17:29:26.294]             base::options(...future.oldOptions)
[17:29:26.294]             if (.Platform$OS.type == "windows") {
[17:29:26.294]                 old_names <- names(...future.oldEnvVars)
[17:29:26.294]                 envs <- base::Sys.getenv()
[17:29:26.294]                 names <- names(envs)
[17:29:26.294]                 common <- intersect(names, old_names)
[17:29:26.294]                 added <- setdiff(names, old_names)
[17:29:26.294]                 removed <- setdiff(old_names, names)
[17:29:26.294]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:26.294]                   envs[common]]
[17:29:26.294]                 NAMES <- toupper(changed)
[17:29:26.294]                 args <- list()
[17:29:26.294]                 for (kk in seq_along(NAMES)) {
[17:29:26.294]                   name <- changed[[kk]]
[17:29:26.294]                   NAME <- NAMES[[kk]]
[17:29:26.294]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.294]                     next
[17:29:26.294]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:26.294]                 }
[17:29:26.294]                 NAMES <- toupper(added)
[17:29:26.294]                 for (kk in seq_along(NAMES)) {
[17:29:26.294]                   name <- added[[kk]]
[17:29:26.294]                   NAME <- NAMES[[kk]]
[17:29:26.294]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.294]                     next
[17:29:26.294]                   args[[name]] <- ""
[17:29:26.294]                 }
[17:29:26.294]                 NAMES <- toupper(removed)
[17:29:26.294]                 for (kk in seq_along(NAMES)) {
[17:29:26.294]                   name <- removed[[kk]]
[17:29:26.294]                   NAME <- NAMES[[kk]]
[17:29:26.294]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.294]                     next
[17:29:26.294]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:26.294]                 }
[17:29:26.294]                 if (length(args) > 0) 
[17:29:26.294]                   base::do.call(base::Sys.setenv, args = args)
[17:29:26.294]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:26.294]             }
[17:29:26.294]             else {
[17:29:26.294]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:26.294]             }
[17:29:26.294]             {
[17:29:26.294]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:26.294]                   0L) {
[17:29:26.294]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:26.294]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:26.294]                   base::options(opts)
[17:29:26.294]                 }
[17:29:26.294]                 {
[17:29:26.294]                   {
[17:29:26.294]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:26.294]                     NULL
[17:29:26.294]                   }
[17:29:26.294]                   options(future.plan = NULL)
[17:29:26.294]                   if (is.na(NA_character_)) 
[17:29:26.294]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:26.294]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:26.294]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:26.294]                     .init = FALSE)
[17:29:26.294]                 }
[17:29:26.294]             }
[17:29:26.294]         }
[17:29:26.294]     })
[17:29:26.294]     if (TRUE) {
[17:29:26.294]         base::sink(type = "output", split = FALSE)
[17:29:26.294]         if (TRUE) {
[17:29:26.294]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:26.294]         }
[17:29:26.294]         else {
[17:29:26.294]             ...future.result["stdout"] <- base::list(NULL)
[17:29:26.294]         }
[17:29:26.294]         base::close(...future.stdout)
[17:29:26.294]         ...future.stdout <- NULL
[17:29:26.294]     }
[17:29:26.294]     ...future.result$conditions <- ...future.conditions
[17:29:26.294]     ...future.result$finished <- base::Sys.time()
[17:29:26.294]     ...future.result
[17:29:26.294] }
[17:29:26.301] MultisessionFuture started
[17:29:26.301] - Launch lazy future ... done
[17:29:26.301] run() for 'MultisessionFuture' ... done
[17:29:26.303] resolve() on list environment ...
[17:29:26.303]  recursive: 0
[17:29:26.304]  length: 3
[17:29:26.305]  elements: 'a', 'b', 'c'
[17:29:26.306] receiveMessageFromWorker() for ClusterFuture ...
[17:29:26.306] - Validating connection of MultisessionFuture
[17:29:26.306] - received message: FutureResult
[17:29:26.307] - Received FutureResult
[17:29:26.307] - Erased future from FutureRegistry
[17:29:26.308] result() for ClusterFuture ...
[17:29:26.308] - result already collected: FutureResult
[17:29:26.308] result() for ClusterFuture ... done
[17:29:26.308] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:26.309] Future #1
[17:29:26.309]  length: 2 (resolved future 1)
[17:29:26.330] receiveMessageFromWorker() for ClusterFuture ...
[17:29:26.331] - Validating connection of MultisessionFuture
[17:29:26.332] - received message: FutureResult
[17:29:26.333] - Received FutureResult
[17:29:26.333] - Erased future from FutureRegistry
[17:29:26.334] result() for ClusterFuture ...
[17:29:26.334] - result already collected: FutureResult
[17:29:26.334] result() for ClusterFuture ... done
[17:29:26.335] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:26.335] Future #2
[17:29:26.336]  length: 1 (resolved future 2)
[17:29:26.336]  length: 0 (resolved future 3)
[17:29:26.337] resolve() on list environment ... DONE
[17:29:26.339] getGlobalsAndPackages() ...
[17:29:26.339] Searching for globals...
[17:29:26.341] - globals found: [1] '{'
[17:29:26.341] Searching for globals ... DONE
[17:29:26.342] Resolving globals: FALSE
[17:29:26.343] 
[17:29:26.343] 
[17:29:26.344] getGlobalsAndPackages() ... DONE
[17:29:26.345] run() for 'Future' ...
[17:29:26.345] - state: 'created'
[17:29:26.346] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:26.368] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:26.368] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:26.369]   - Field: 'node'
[17:29:26.369]   - Field: 'label'
[17:29:26.369]   - Field: 'local'
[17:29:26.370]   - Field: 'owner'
[17:29:26.370]   - Field: 'envir'
[17:29:26.370]   - Field: 'workers'
[17:29:26.371]   - Field: 'packages'
[17:29:26.371]   - Field: 'gc'
[17:29:26.371]   - Field: 'conditions'
[17:29:26.372]   - Field: 'persistent'
[17:29:26.372]   - Field: 'expr'
[17:29:26.372]   - Field: 'uuid'
[17:29:26.373]   - Field: 'seed'
[17:29:26.373]   - Field: 'version'
[17:29:26.373]   - Field: 'result'
[17:29:26.374]   - Field: 'asynchronous'
[17:29:26.374]   - Field: 'calls'
[17:29:26.374]   - Field: 'globals'
[17:29:26.375]   - Field: 'stdout'
[17:29:26.375]   - Field: 'earlySignal'
[17:29:26.375]   - Field: 'lazy'
[17:29:26.376]   - Field: 'state'
[17:29:26.376] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:26.376] - Launch lazy future ...
[17:29:26.377] Packages needed by the future expression (n = 0): <none>
[17:29:26.377] Packages needed by future strategies (n = 0): <none>
[17:29:26.379] {
[17:29:26.379]     {
[17:29:26.379]         {
[17:29:26.379]             ...future.startTime <- base::Sys.time()
[17:29:26.379]             {
[17:29:26.379]                 {
[17:29:26.379]                   {
[17:29:26.379]                     {
[17:29:26.379]                       base::local({
[17:29:26.379]                         has_future <- base::requireNamespace("future", 
[17:29:26.379]                           quietly = TRUE)
[17:29:26.379]                         if (has_future) {
[17:29:26.379]                           ns <- base::getNamespace("future")
[17:29:26.379]                           version <- ns[[".package"]][["version"]]
[17:29:26.379]                           if (is.null(version)) 
[17:29:26.379]                             version <- utils::packageVersion("future")
[17:29:26.379]                         }
[17:29:26.379]                         else {
[17:29:26.379]                           version <- NULL
[17:29:26.379]                         }
[17:29:26.379]                         if (!has_future || version < "1.8.0") {
[17:29:26.379]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:26.379]                             "", base::R.version$version.string), 
[17:29:26.379]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:26.379]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:26.379]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:26.379]                               "release", "version")], collapse = " "), 
[17:29:26.379]                             hostname = base::Sys.info()[["nodename"]])
[17:29:26.379]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:26.379]                             info)
[17:29:26.379]                           info <- base::paste(info, collapse = "; ")
[17:29:26.379]                           if (!has_future) {
[17:29:26.379]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:26.379]                               info)
[17:29:26.379]                           }
[17:29:26.379]                           else {
[17:29:26.379]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:26.379]                               info, version)
[17:29:26.379]                           }
[17:29:26.379]                           base::stop(msg)
[17:29:26.379]                         }
[17:29:26.379]                       })
[17:29:26.379]                     }
[17:29:26.379]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:26.379]                     base::options(mc.cores = 1L)
[17:29:26.379]                   }
[17:29:26.379]                   ...future.strategy.old <- future::plan("list")
[17:29:26.379]                   options(future.plan = NULL)
[17:29:26.379]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:26.379]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:26.379]                 }
[17:29:26.379]                 ...future.workdir <- getwd()
[17:29:26.379]             }
[17:29:26.379]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:26.379]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:26.379]         }
[17:29:26.379]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:26.379]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:26.379]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:26.379]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:26.379]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:26.379]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:26.379]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:26.379]             base::names(...future.oldOptions))
[17:29:26.379]     }
[17:29:26.379]     if (FALSE) {
[17:29:26.379]     }
[17:29:26.379]     else {
[17:29:26.379]         if (TRUE) {
[17:29:26.379]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:26.379]                 open = "w")
[17:29:26.379]         }
[17:29:26.379]         else {
[17:29:26.379]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:26.379]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:26.379]         }
[17:29:26.379]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:26.379]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:26.379]             base::sink(type = "output", split = FALSE)
[17:29:26.379]             base::close(...future.stdout)
[17:29:26.379]         }, add = TRUE)
[17:29:26.379]     }
[17:29:26.379]     ...future.frame <- base::sys.nframe()
[17:29:26.379]     ...future.conditions <- base::list()
[17:29:26.379]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:26.379]     if (FALSE) {
[17:29:26.379]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:26.379]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:26.379]     }
[17:29:26.379]     ...future.result <- base::tryCatch({
[17:29:26.379]         base::withCallingHandlers({
[17:29:26.379]             ...future.value <- base::withVisible(base::local({
[17:29:26.379]                 ...future.makeSendCondition <- base::local({
[17:29:26.379]                   sendCondition <- NULL
[17:29:26.379]                   function(frame = 1L) {
[17:29:26.379]                     if (is.function(sendCondition)) 
[17:29:26.379]                       return(sendCondition)
[17:29:26.379]                     ns <- getNamespace("parallel")
[17:29:26.379]                     if (exists("sendData", mode = "function", 
[17:29:26.379]                       envir = ns)) {
[17:29:26.379]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:26.379]                         envir = ns)
[17:29:26.379]                       envir <- sys.frame(frame)
[17:29:26.379]                       master <- NULL
[17:29:26.379]                       while (!identical(envir, .GlobalEnv) && 
[17:29:26.379]                         !identical(envir, emptyenv())) {
[17:29:26.379]                         if (exists("master", mode = "list", envir = envir, 
[17:29:26.379]                           inherits = FALSE)) {
[17:29:26.379]                           master <- get("master", mode = "list", 
[17:29:26.379]                             envir = envir, inherits = FALSE)
[17:29:26.379]                           if (inherits(master, c("SOCKnode", 
[17:29:26.379]                             "SOCK0node"))) {
[17:29:26.379]                             sendCondition <<- function(cond) {
[17:29:26.379]                               data <- list(type = "VALUE", value = cond, 
[17:29:26.379]                                 success = TRUE)
[17:29:26.379]                               parallel_sendData(master, data)
[17:29:26.379]                             }
[17:29:26.379]                             return(sendCondition)
[17:29:26.379]                           }
[17:29:26.379]                         }
[17:29:26.379]                         frame <- frame + 1L
[17:29:26.379]                         envir <- sys.frame(frame)
[17:29:26.379]                       }
[17:29:26.379]                     }
[17:29:26.379]                     sendCondition <<- function(cond) NULL
[17:29:26.379]                   }
[17:29:26.379]                 })
[17:29:26.379]                 withCallingHandlers({
[17:29:26.379]                   {
[17:29:26.379]                     1
[17:29:26.379]                   }
[17:29:26.379]                 }, immediateCondition = function(cond) {
[17:29:26.379]                   sendCondition <- ...future.makeSendCondition()
[17:29:26.379]                   sendCondition(cond)
[17:29:26.379]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.379]                   {
[17:29:26.379]                     inherits <- base::inherits
[17:29:26.379]                     invokeRestart <- base::invokeRestart
[17:29:26.379]                     is.null <- base::is.null
[17:29:26.379]                     muffled <- FALSE
[17:29:26.379]                     if (inherits(cond, "message")) {
[17:29:26.379]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:26.379]                       if (muffled) 
[17:29:26.379]                         invokeRestart("muffleMessage")
[17:29:26.379]                     }
[17:29:26.379]                     else if (inherits(cond, "warning")) {
[17:29:26.379]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:26.379]                       if (muffled) 
[17:29:26.379]                         invokeRestart("muffleWarning")
[17:29:26.379]                     }
[17:29:26.379]                     else if (inherits(cond, "condition")) {
[17:29:26.379]                       if (!is.null(pattern)) {
[17:29:26.379]                         computeRestarts <- base::computeRestarts
[17:29:26.379]                         grepl <- base::grepl
[17:29:26.379]                         restarts <- computeRestarts(cond)
[17:29:26.379]                         for (restart in restarts) {
[17:29:26.379]                           name <- restart$name
[17:29:26.379]                           if (is.null(name)) 
[17:29:26.379]                             next
[17:29:26.379]                           if (!grepl(pattern, name)) 
[17:29:26.379]                             next
[17:29:26.379]                           invokeRestart(restart)
[17:29:26.379]                           muffled <- TRUE
[17:29:26.379]                           break
[17:29:26.379]                         }
[17:29:26.379]                       }
[17:29:26.379]                     }
[17:29:26.379]                     invisible(muffled)
[17:29:26.379]                   }
[17:29:26.379]                   muffleCondition(cond)
[17:29:26.379]                 })
[17:29:26.379]             }))
[17:29:26.379]             future::FutureResult(value = ...future.value$value, 
[17:29:26.379]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:26.379]                   ...future.rng), globalenv = if (FALSE) 
[17:29:26.379]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:26.379]                     ...future.globalenv.names))
[17:29:26.379]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:26.379]         }, condition = base::local({
[17:29:26.379]             c <- base::c
[17:29:26.379]             inherits <- base::inherits
[17:29:26.379]             invokeRestart <- base::invokeRestart
[17:29:26.379]             length <- base::length
[17:29:26.379]             list <- base::list
[17:29:26.379]             seq.int <- base::seq.int
[17:29:26.379]             signalCondition <- base::signalCondition
[17:29:26.379]             sys.calls <- base::sys.calls
[17:29:26.379]             `[[` <- base::`[[`
[17:29:26.379]             `+` <- base::`+`
[17:29:26.379]             `<<-` <- base::`<<-`
[17:29:26.379]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:26.379]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:26.379]                   3L)]
[17:29:26.379]             }
[17:29:26.379]             function(cond) {
[17:29:26.379]                 is_error <- inherits(cond, "error")
[17:29:26.379]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:26.379]                   NULL)
[17:29:26.379]                 if (is_error) {
[17:29:26.379]                   sessionInformation <- function() {
[17:29:26.379]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:26.379]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:26.379]                       search = base::search(), system = base::Sys.info())
[17:29:26.379]                   }
[17:29:26.379]                   ...future.conditions[[length(...future.conditions) + 
[17:29:26.379]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:26.379]                     cond$call), session = sessionInformation(), 
[17:29:26.379]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:26.379]                   signalCondition(cond)
[17:29:26.379]                 }
[17:29:26.379]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:26.379]                 "immediateCondition"))) {
[17:29:26.379]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:26.379]                   ...future.conditions[[length(...future.conditions) + 
[17:29:26.379]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:26.379]                   if (TRUE && !signal) {
[17:29:26.379]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.379]                     {
[17:29:26.379]                       inherits <- base::inherits
[17:29:26.379]                       invokeRestart <- base::invokeRestart
[17:29:26.379]                       is.null <- base::is.null
[17:29:26.379]                       muffled <- FALSE
[17:29:26.379]                       if (inherits(cond, "message")) {
[17:29:26.379]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:26.379]                         if (muffled) 
[17:29:26.379]                           invokeRestart("muffleMessage")
[17:29:26.379]                       }
[17:29:26.379]                       else if (inherits(cond, "warning")) {
[17:29:26.379]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:26.379]                         if (muffled) 
[17:29:26.379]                           invokeRestart("muffleWarning")
[17:29:26.379]                       }
[17:29:26.379]                       else if (inherits(cond, "condition")) {
[17:29:26.379]                         if (!is.null(pattern)) {
[17:29:26.379]                           computeRestarts <- base::computeRestarts
[17:29:26.379]                           grepl <- base::grepl
[17:29:26.379]                           restarts <- computeRestarts(cond)
[17:29:26.379]                           for (restart in restarts) {
[17:29:26.379]                             name <- restart$name
[17:29:26.379]                             if (is.null(name)) 
[17:29:26.379]                               next
[17:29:26.379]                             if (!grepl(pattern, name)) 
[17:29:26.379]                               next
[17:29:26.379]                             invokeRestart(restart)
[17:29:26.379]                             muffled <- TRUE
[17:29:26.379]                             break
[17:29:26.379]                           }
[17:29:26.379]                         }
[17:29:26.379]                       }
[17:29:26.379]                       invisible(muffled)
[17:29:26.379]                     }
[17:29:26.379]                     muffleCondition(cond, pattern = "^muffle")
[17:29:26.379]                   }
[17:29:26.379]                 }
[17:29:26.379]                 else {
[17:29:26.379]                   if (TRUE) {
[17:29:26.379]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.379]                     {
[17:29:26.379]                       inherits <- base::inherits
[17:29:26.379]                       invokeRestart <- base::invokeRestart
[17:29:26.379]                       is.null <- base::is.null
[17:29:26.379]                       muffled <- FALSE
[17:29:26.379]                       if (inherits(cond, "message")) {
[17:29:26.379]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:26.379]                         if (muffled) 
[17:29:26.379]                           invokeRestart("muffleMessage")
[17:29:26.379]                       }
[17:29:26.379]                       else if (inherits(cond, "warning")) {
[17:29:26.379]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:26.379]                         if (muffled) 
[17:29:26.379]                           invokeRestart("muffleWarning")
[17:29:26.379]                       }
[17:29:26.379]                       else if (inherits(cond, "condition")) {
[17:29:26.379]                         if (!is.null(pattern)) {
[17:29:26.379]                           computeRestarts <- base::computeRestarts
[17:29:26.379]                           grepl <- base::grepl
[17:29:26.379]                           restarts <- computeRestarts(cond)
[17:29:26.379]                           for (restart in restarts) {
[17:29:26.379]                             name <- restart$name
[17:29:26.379]                             if (is.null(name)) 
[17:29:26.379]                               next
[17:29:26.379]                             if (!grepl(pattern, name)) 
[17:29:26.379]                               next
[17:29:26.379]                             invokeRestart(restart)
[17:29:26.379]                             muffled <- TRUE
[17:29:26.379]                             break
[17:29:26.379]                           }
[17:29:26.379]                         }
[17:29:26.379]                       }
[17:29:26.379]                       invisible(muffled)
[17:29:26.379]                     }
[17:29:26.379]                     muffleCondition(cond, pattern = "^muffle")
[17:29:26.379]                   }
[17:29:26.379]                 }
[17:29:26.379]             }
[17:29:26.379]         }))
[17:29:26.379]     }, error = function(ex) {
[17:29:26.379]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:26.379]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:26.379]                 ...future.rng), started = ...future.startTime, 
[17:29:26.379]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:26.379]             version = "1.8"), class = "FutureResult")
[17:29:26.379]     }, finally = {
[17:29:26.379]         if (!identical(...future.workdir, getwd())) 
[17:29:26.379]             setwd(...future.workdir)
[17:29:26.379]         {
[17:29:26.379]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:26.379]                 ...future.oldOptions$nwarnings <- NULL
[17:29:26.379]             }
[17:29:26.379]             base::options(...future.oldOptions)
[17:29:26.379]             if (.Platform$OS.type == "windows") {
[17:29:26.379]                 old_names <- names(...future.oldEnvVars)
[17:29:26.379]                 envs <- base::Sys.getenv()
[17:29:26.379]                 names <- names(envs)
[17:29:26.379]                 common <- intersect(names, old_names)
[17:29:26.379]                 added <- setdiff(names, old_names)
[17:29:26.379]                 removed <- setdiff(old_names, names)
[17:29:26.379]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:26.379]                   envs[common]]
[17:29:26.379]                 NAMES <- toupper(changed)
[17:29:26.379]                 args <- list()
[17:29:26.379]                 for (kk in seq_along(NAMES)) {
[17:29:26.379]                   name <- changed[[kk]]
[17:29:26.379]                   NAME <- NAMES[[kk]]
[17:29:26.379]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.379]                     next
[17:29:26.379]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:26.379]                 }
[17:29:26.379]                 NAMES <- toupper(added)
[17:29:26.379]                 for (kk in seq_along(NAMES)) {
[17:29:26.379]                   name <- added[[kk]]
[17:29:26.379]                   NAME <- NAMES[[kk]]
[17:29:26.379]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.379]                     next
[17:29:26.379]                   args[[name]] <- ""
[17:29:26.379]                 }
[17:29:26.379]                 NAMES <- toupper(removed)
[17:29:26.379]                 for (kk in seq_along(NAMES)) {
[17:29:26.379]                   name <- removed[[kk]]
[17:29:26.379]                   NAME <- NAMES[[kk]]
[17:29:26.379]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.379]                     next
[17:29:26.379]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:26.379]                 }
[17:29:26.379]                 if (length(args) > 0) 
[17:29:26.379]                   base::do.call(base::Sys.setenv, args = args)
[17:29:26.379]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:26.379]             }
[17:29:26.379]             else {
[17:29:26.379]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:26.379]             }
[17:29:26.379]             {
[17:29:26.379]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:26.379]                   0L) {
[17:29:26.379]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:26.379]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:26.379]                   base::options(opts)
[17:29:26.379]                 }
[17:29:26.379]                 {
[17:29:26.379]                   {
[17:29:26.379]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:26.379]                     NULL
[17:29:26.379]                   }
[17:29:26.379]                   options(future.plan = NULL)
[17:29:26.379]                   if (is.na(NA_character_)) 
[17:29:26.379]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:26.379]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:26.379]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:26.379]                     .init = FALSE)
[17:29:26.379]                 }
[17:29:26.379]             }
[17:29:26.379]         }
[17:29:26.379]     })
[17:29:26.379]     if (TRUE) {
[17:29:26.379]         base::sink(type = "output", split = FALSE)
[17:29:26.379]         if (TRUE) {
[17:29:26.379]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:26.379]         }
[17:29:26.379]         else {
[17:29:26.379]             ...future.result["stdout"] <- base::list(NULL)
[17:29:26.379]         }
[17:29:26.379]         base::close(...future.stdout)
[17:29:26.379]         ...future.stdout <- NULL
[17:29:26.379]     }
[17:29:26.379]     ...future.result$conditions <- ...future.conditions
[17:29:26.379]     ...future.result$finished <- base::Sys.time()
[17:29:26.379]     ...future.result
[17:29:26.379] }
[17:29:26.390] MultisessionFuture started
[17:29:26.391] - Launch lazy future ... done
[17:29:26.392] run() for 'MultisessionFuture' ... done
[17:29:26.393] getGlobalsAndPackages() ...
[17:29:26.393] Searching for globals...
[17:29:26.395] - globals found: [1] '{'
[17:29:26.396] Searching for globals ... DONE
[17:29:26.396] Resolving globals: FALSE
[17:29:26.397] 
[17:29:26.397] 
[17:29:26.397] getGlobalsAndPackages() ... DONE
[17:29:26.398] run() for 'Future' ...
[17:29:26.398] - state: 'created'
[17:29:26.399] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:26.421] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:26.421] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:26.422]   - Field: 'node'
[17:29:26.422]   - Field: 'label'
[17:29:26.422]   - Field: 'local'
[17:29:26.423]   - Field: 'owner'
[17:29:26.423]   - Field: 'envir'
[17:29:26.423]   - Field: 'workers'
[17:29:26.424]   - Field: 'packages'
[17:29:26.424]   - Field: 'gc'
[17:29:26.424]   - Field: 'conditions'
[17:29:26.425]   - Field: 'persistent'
[17:29:26.425]   - Field: 'expr'
[17:29:26.425]   - Field: 'uuid'
[17:29:26.426]   - Field: 'seed'
[17:29:26.426]   - Field: 'version'
[17:29:26.426]   - Field: 'result'
[17:29:26.427]   - Field: 'asynchronous'
[17:29:26.427]   - Field: 'calls'
[17:29:26.427]   - Field: 'globals'
[17:29:26.428]   - Field: 'stdout'
[17:29:26.428]   - Field: 'earlySignal'
[17:29:26.428]   - Field: 'lazy'
[17:29:26.429]   - Field: 'state'
[17:29:26.429] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:26.429] - Launch lazy future ...
[17:29:26.430] Packages needed by the future expression (n = 0): <none>
[17:29:26.430] Packages needed by future strategies (n = 0): <none>
[17:29:26.432] {
[17:29:26.432]     {
[17:29:26.432]         {
[17:29:26.432]             ...future.startTime <- base::Sys.time()
[17:29:26.432]             {
[17:29:26.432]                 {
[17:29:26.432]                   {
[17:29:26.432]                     {
[17:29:26.432]                       base::local({
[17:29:26.432]                         has_future <- base::requireNamespace("future", 
[17:29:26.432]                           quietly = TRUE)
[17:29:26.432]                         if (has_future) {
[17:29:26.432]                           ns <- base::getNamespace("future")
[17:29:26.432]                           version <- ns[[".package"]][["version"]]
[17:29:26.432]                           if (is.null(version)) 
[17:29:26.432]                             version <- utils::packageVersion("future")
[17:29:26.432]                         }
[17:29:26.432]                         else {
[17:29:26.432]                           version <- NULL
[17:29:26.432]                         }
[17:29:26.432]                         if (!has_future || version < "1.8.0") {
[17:29:26.432]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:26.432]                             "", base::R.version$version.string), 
[17:29:26.432]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:26.432]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:26.432]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:26.432]                               "release", "version")], collapse = " "), 
[17:29:26.432]                             hostname = base::Sys.info()[["nodename"]])
[17:29:26.432]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:26.432]                             info)
[17:29:26.432]                           info <- base::paste(info, collapse = "; ")
[17:29:26.432]                           if (!has_future) {
[17:29:26.432]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:26.432]                               info)
[17:29:26.432]                           }
[17:29:26.432]                           else {
[17:29:26.432]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:26.432]                               info, version)
[17:29:26.432]                           }
[17:29:26.432]                           base::stop(msg)
[17:29:26.432]                         }
[17:29:26.432]                       })
[17:29:26.432]                     }
[17:29:26.432]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:26.432]                     base::options(mc.cores = 1L)
[17:29:26.432]                   }
[17:29:26.432]                   ...future.strategy.old <- future::plan("list")
[17:29:26.432]                   options(future.plan = NULL)
[17:29:26.432]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:26.432]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:26.432]                 }
[17:29:26.432]                 ...future.workdir <- getwd()
[17:29:26.432]             }
[17:29:26.432]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:26.432]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:26.432]         }
[17:29:26.432]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:26.432]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:26.432]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:26.432]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:26.432]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:26.432]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:26.432]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:26.432]             base::names(...future.oldOptions))
[17:29:26.432]     }
[17:29:26.432]     if (FALSE) {
[17:29:26.432]     }
[17:29:26.432]     else {
[17:29:26.432]         if (TRUE) {
[17:29:26.432]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:26.432]                 open = "w")
[17:29:26.432]         }
[17:29:26.432]         else {
[17:29:26.432]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:26.432]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:26.432]         }
[17:29:26.432]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:26.432]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:26.432]             base::sink(type = "output", split = FALSE)
[17:29:26.432]             base::close(...future.stdout)
[17:29:26.432]         }, add = TRUE)
[17:29:26.432]     }
[17:29:26.432]     ...future.frame <- base::sys.nframe()
[17:29:26.432]     ...future.conditions <- base::list()
[17:29:26.432]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:26.432]     if (FALSE) {
[17:29:26.432]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:26.432]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:26.432]     }
[17:29:26.432]     ...future.result <- base::tryCatch({
[17:29:26.432]         base::withCallingHandlers({
[17:29:26.432]             ...future.value <- base::withVisible(base::local({
[17:29:26.432]                 ...future.makeSendCondition <- base::local({
[17:29:26.432]                   sendCondition <- NULL
[17:29:26.432]                   function(frame = 1L) {
[17:29:26.432]                     if (is.function(sendCondition)) 
[17:29:26.432]                       return(sendCondition)
[17:29:26.432]                     ns <- getNamespace("parallel")
[17:29:26.432]                     if (exists("sendData", mode = "function", 
[17:29:26.432]                       envir = ns)) {
[17:29:26.432]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:26.432]                         envir = ns)
[17:29:26.432]                       envir <- sys.frame(frame)
[17:29:26.432]                       master <- NULL
[17:29:26.432]                       while (!identical(envir, .GlobalEnv) && 
[17:29:26.432]                         !identical(envir, emptyenv())) {
[17:29:26.432]                         if (exists("master", mode = "list", envir = envir, 
[17:29:26.432]                           inherits = FALSE)) {
[17:29:26.432]                           master <- get("master", mode = "list", 
[17:29:26.432]                             envir = envir, inherits = FALSE)
[17:29:26.432]                           if (inherits(master, c("SOCKnode", 
[17:29:26.432]                             "SOCK0node"))) {
[17:29:26.432]                             sendCondition <<- function(cond) {
[17:29:26.432]                               data <- list(type = "VALUE", value = cond, 
[17:29:26.432]                                 success = TRUE)
[17:29:26.432]                               parallel_sendData(master, data)
[17:29:26.432]                             }
[17:29:26.432]                             return(sendCondition)
[17:29:26.432]                           }
[17:29:26.432]                         }
[17:29:26.432]                         frame <- frame + 1L
[17:29:26.432]                         envir <- sys.frame(frame)
[17:29:26.432]                       }
[17:29:26.432]                     }
[17:29:26.432]                     sendCondition <<- function(cond) NULL
[17:29:26.432]                   }
[17:29:26.432]                 })
[17:29:26.432]                 withCallingHandlers({
[17:29:26.432]                   {
[17:29:26.432]                     2
[17:29:26.432]                   }
[17:29:26.432]                 }, immediateCondition = function(cond) {
[17:29:26.432]                   sendCondition <- ...future.makeSendCondition()
[17:29:26.432]                   sendCondition(cond)
[17:29:26.432]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.432]                   {
[17:29:26.432]                     inherits <- base::inherits
[17:29:26.432]                     invokeRestart <- base::invokeRestart
[17:29:26.432]                     is.null <- base::is.null
[17:29:26.432]                     muffled <- FALSE
[17:29:26.432]                     if (inherits(cond, "message")) {
[17:29:26.432]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:26.432]                       if (muffled) 
[17:29:26.432]                         invokeRestart("muffleMessage")
[17:29:26.432]                     }
[17:29:26.432]                     else if (inherits(cond, "warning")) {
[17:29:26.432]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:26.432]                       if (muffled) 
[17:29:26.432]                         invokeRestart("muffleWarning")
[17:29:26.432]                     }
[17:29:26.432]                     else if (inherits(cond, "condition")) {
[17:29:26.432]                       if (!is.null(pattern)) {
[17:29:26.432]                         computeRestarts <- base::computeRestarts
[17:29:26.432]                         grepl <- base::grepl
[17:29:26.432]                         restarts <- computeRestarts(cond)
[17:29:26.432]                         for (restart in restarts) {
[17:29:26.432]                           name <- restart$name
[17:29:26.432]                           if (is.null(name)) 
[17:29:26.432]                             next
[17:29:26.432]                           if (!grepl(pattern, name)) 
[17:29:26.432]                             next
[17:29:26.432]                           invokeRestart(restart)
[17:29:26.432]                           muffled <- TRUE
[17:29:26.432]                           break
[17:29:26.432]                         }
[17:29:26.432]                       }
[17:29:26.432]                     }
[17:29:26.432]                     invisible(muffled)
[17:29:26.432]                   }
[17:29:26.432]                   muffleCondition(cond)
[17:29:26.432]                 })
[17:29:26.432]             }))
[17:29:26.432]             future::FutureResult(value = ...future.value$value, 
[17:29:26.432]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:26.432]                   ...future.rng), globalenv = if (FALSE) 
[17:29:26.432]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:26.432]                     ...future.globalenv.names))
[17:29:26.432]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:26.432]         }, condition = base::local({
[17:29:26.432]             c <- base::c
[17:29:26.432]             inherits <- base::inherits
[17:29:26.432]             invokeRestart <- base::invokeRestart
[17:29:26.432]             length <- base::length
[17:29:26.432]             list <- base::list
[17:29:26.432]             seq.int <- base::seq.int
[17:29:26.432]             signalCondition <- base::signalCondition
[17:29:26.432]             sys.calls <- base::sys.calls
[17:29:26.432]             `[[` <- base::`[[`
[17:29:26.432]             `+` <- base::`+`
[17:29:26.432]             `<<-` <- base::`<<-`
[17:29:26.432]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:26.432]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:26.432]                   3L)]
[17:29:26.432]             }
[17:29:26.432]             function(cond) {
[17:29:26.432]                 is_error <- inherits(cond, "error")
[17:29:26.432]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:26.432]                   NULL)
[17:29:26.432]                 if (is_error) {
[17:29:26.432]                   sessionInformation <- function() {
[17:29:26.432]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:26.432]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:26.432]                       search = base::search(), system = base::Sys.info())
[17:29:26.432]                   }
[17:29:26.432]                   ...future.conditions[[length(...future.conditions) + 
[17:29:26.432]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:26.432]                     cond$call), session = sessionInformation(), 
[17:29:26.432]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:26.432]                   signalCondition(cond)
[17:29:26.432]                 }
[17:29:26.432]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:26.432]                 "immediateCondition"))) {
[17:29:26.432]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:26.432]                   ...future.conditions[[length(...future.conditions) + 
[17:29:26.432]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:26.432]                   if (TRUE && !signal) {
[17:29:26.432]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.432]                     {
[17:29:26.432]                       inherits <- base::inherits
[17:29:26.432]                       invokeRestart <- base::invokeRestart
[17:29:26.432]                       is.null <- base::is.null
[17:29:26.432]                       muffled <- FALSE
[17:29:26.432]                       if (inherits(cond, "message")) {
[17:29:26.432]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:26.432]                         if (muffled) 
[17:29:26.432]                           invokeRestart("muffleMessage")
[17:29:26.432]                       }
[17:29:26.432]                       else if (inherits(cond, "warning")) {
[17:29:26.432]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:26.432]                         if (muffled) 
[17:29:26.432]                           invokeRestart("muffleWarning")
[17:29:26.432]                       }
[17:29:26.432]                       else if (inherits(cond, "condition")) {
[17:29:26.432]                         if (!is.null(pattern)) {
[17:29:26.432]                           computeRestarts <- base::computeRestarts
[17:29:26.432]                           grepl <- base::grepl
[17:29:26.432]                           restarts <- computeRestarts(cond)
[17:29:26.432]                           for (restart in restarts) {
[17:29:26.432]                             name <- restart$name
[17:29:26.432]                             if (is.null(name)) 
[17:29:26.432]                               next
[17:29:26.432]                             if (!grepl(pattern, name)) 
[17:29:26.432]                               next
[17:29:26.432]                             invokeRestart(restart)
[17:29:26.432]                             muffled <- TRUE
[17:29:26.432]                             break
[17:29:26.432]                           }
[17:29:26.432]                         }
[17:29:26.432]                       }
[17:29:26.432]                       invisible(muffled)
[17:29:26.432]                     }
[17:29:26.432]                     muffleCondition(cond, pattern = "^muffle")
[17:29:26.432]                   }
[17:29:26.432]                 }
[17:29:26.432]                 else {
[17:29:26.432]                   if (TRUE) {
[17:29:26.432]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.432]                     {
[17:29:26.432]                       inherits <- base::inherits
[17:29:26.432]                       invokeRestart <- base::invokeRestart
[17:29:26.432]                       is.null <- base::is.null
[17:29:26.432]                       muffled <- FALSE
[17:29:26.432]                       if (inherits(cond, "message")) {
[17:29:26.432]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:26.432]                         if (muffled) 
[17:29:26.432]                           invokeRestart("muffleMessage")
[17:29:26.432]                       }
[17:29:26.432]                       else if (inherits(cond, "warning")) {
[17:29:26.432]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:26.432]                         if (muffled) 
[17:29:26.432]                           invokeRestart("muffleWarning")
[17:29:26.432]                       }
[17:29:26.432]                       else if (inherits(cond, "condition")) {
[17:29:26.432]                         if (!is.null(pattern)) {
[17:29:26.432]                           computeRestarts <- base::computeRestarts
[17:29:26.432]                           grepl <- base::grepl
[17:29:26.432]                           restarts <- computeRestarts(cond)
[17:29:26.432]                           for (restart in restarts) {
[17:29:26.432]                             name <- restart$name
[17:29:26.432]                             if (is.null(name)) 
[17:29:26.432]                               next
[17:29:26.432]                             if (!grepl(pattern, name)) 
[17:29:26.432]                               next
[17:29:26.432]                             invokeRestart(restart)
[17:29:26.432]                             muffled <- TRUE
[17:29:26.432]                             break
[17:29:26.432]                           }
[17:29:26.432]                         }
[17:29:26.432]                       }
[17:29:26.432]                       invisible(muffled)
[17:29:26.432]                     }
[17:29:26.432]                     muffleCondition(cond, pattern = "^muffle")
[17:29:26.432]                   }
[17:29:26.432]                 }
[17:29:26.432]             }
[17:29:26.432]         }))
[17:29:26.432]     }, error = function(ex) {
[17:29:26.432]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:26.432]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:26.432]                 ...future.rng), started = ...future.startTime, 
[17:29:26.432]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:26.432]             version = "1.8"), class = "FutureResult")
[17:29:26.432]     }, finally = {
[17:29:26.432]         if (!identical(...future.workdir, getwd())) 
[17:29:26.432]             setwd(...future.workdir)
[17:29:26.432]         {
[17:29:26.432]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:26.432]                 ...future.oldOptions$nwarnings <- NULL
[17:29:26.432]             }
[17:29:26.432]             base::options(...future.oldOptions)
[17:29:26.432]             if (.Platform$OS.type == "windows") {
[17:29:26.432]                 old_names <- names(...future.oldEnvVars)
[17:29:26.432]                 envs <- base::Sys.getenv()
[17:29:26.432]                 names <- names(envs)
[17:29:26.432]                 common <- intersect(names, old_names)
[17:29:26.432]                 added <- setdiff(names, old_names)
[17:29:26.432]                 removed <- setdiff(old_names, names)
[17:29:26.432]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:26.432]                   envs[common]]
[17:29:26.432]                 NAMES <- toupper(changed)
[17:29:26.432]                 args <- list()
[17:29:26.432]                 for (kk in seq_along(NAMES)) {
[17:29:26.432]                   name <- changed[[kk]]
[17:29:26.432]                   NAME <- NAMES[[kk]]
[17:29:26.432]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.432]                     next
[17:29:26.432]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:26.432]                 }
[17:29:26.432]                 NAMES <- toupper(added)
[17:29:26.432]                 for (kk in seq_along(NAMES)) {
[17:29:26.432]                   name <- added[[kk]]
[17:29:26.432]                   NAME <- NAMES[[kk]]
[17:29:26.432]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.432]                     next
[17:29:26.432]                   args[[name]] <- ""
[17:29:26.432]                 }
[17:29:26.432]                 NAMES <- toupper(removed)
[17:29:26.432]                 for (kk in seq_along(NAMES)) {
[17:29:26.432]                   name <- removed[[kk]]
[17:29:26.432]                   NAME <- NAMES[[kk]]
[17:29:26.432]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.432]                     next
[17:29:26.432]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:26.432]                 }
[17:29:26.432]                 if (length(args) > 0) 
[17:29:26.432]                   base::do.call(base::Sys.setenv, args = args)
[17:29:26.432]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:26.432]             }
[17:29:26.432]             else {
[17:29:26.432]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:26.432]             }
[17:29:26.432]             {
[17:29:26.432]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:26.432]                   0L) {
[17:29:26.432]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:26.432]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:26.432]                   base::options(opts)
[17:29:26.432]                 }
[17:29:26.432]                 {
[17:29:26.432]                   {
[17:29:26.432]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:26.432]                     NULL
[17:29:26.432]                   }
[17:29:26.432]                   options(future.plan = NULL)
[17:29:26.432]                   if (is.na(NA_character_)) 
[17:29:26.432]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:26.432]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:26.432]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:26.432]                     .init = FALSE)
[17:29:26.432]                 }
[17:29:26.432]             }
[17:29:26.432]         }
[17:29:26.432]     })
[17:29:26.432]     if (TRUE) {
[17:29:26.432]         base::sink(type = "output", split = FALSE)
[17:29:26.432]         if (TRUE) {
[17:29:26.432]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:26.432]         }
[17:29:26.432]         else {
[17:29:26.432]             ...future.result["stdout"] <- base::list(NULL)
[17:29:26.432]         }
[17:29:26.432]         base::close(...future.stdout)
[17:29:26.432]         ...future.stdout <- NULL
[17:29:26.432]     }
[17:29:26.432]     ...future.result$conditions <- ...future.conditions
[17:29:26.432]     ...future.result$finished <- base::Sys.time()
[17:29:26.432]     ...future.result
[17:29:26.432] }
[17:29:26.442] MultisessionFuture started
[17:29:26.442] - Launch lazy future ... done
[17:29:26.443] run() for 'MultisessionFuture' ... done
[17:29:26.444] resolve() on list environment ...
[17:29:26.445]  recursive: 0
[17:29:26.446]  length: 3
[17:29:26.446]  elements: 'a', 'b', 'c'
[17:29:26.447] receiveMessageFromWorker() for ClusterFuture ...
[17:29:26.447] - Validating connection of MultisessionFuture
[17:29:26.448] - received message: FutureResult
[17:29:26.448] - Received FutureResult
[17:29:26.448] - Erased future from FutureRegistry
[17:29:26.449] result() for ClusterFuture ...
[17:29:26.449] - result already collected: FutureResult
[17:29:26.449] result() for ClusterFuture ... done
[17:29:26.450] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:26.450] Future #1
[17:29:26.450]  length: 2 (resolved future 1)
[17:29:26.467] receiveMessageFromWorker() for ClusterFuture ...
[17:29:26.467] - Validating connection of MultisessionFuture
[17:29:26.468] - received message: FutureResult
[17:29:26.468] - Received FutureResult
[17:29:26.469] - Erased future from FutureRegistry
[17:29:26.469] result() for ClusterFuture ...
[17:29:26.469] - result already collected: FutureResult
[17:29:26.470] result() for ClusterFuture ... done
[17:29:26.470] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:26.470] Future #2
[17:29:26.470]  length: 1 (resolved future 2)
[17:29:26.471]  length: 0 (resolved future 3)
[17:29:26.471] resolve() on list environment ... DONE
[17:29:26.472] getGlobalsAndPackages() ...
[17:29:26.473] Searching for globals...
[17:29:26.474] - globals found: [1] '{'
[17:29:26.479] Searching for globals ... DONE
[17:29:26.479] Resolving globals: FALSE
[17:29:26.480] 
[17:29:26.480] 
[17:29:26.480] getGlobalsAndPackages() ... DONE
[17:29:26.481] run() for 'Future' ...
[17:29:26.481] - state: 'created'
[17:29:26.482] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:26.502] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:26.502] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:26.502]   - Field: 'node'
[17:29:26.503]   - Field: 'label'
[17:29:26.503]   - Field: 'local'
[17:29:26.503]   - Field: 'owner'
[17:29:26.504]   - Field: 'envir'
[17:29:26.504]   - Field: 'workers'
[17:29:26.504]   - Field: 'packages'
[17:29:26.505]   - Field: 'gc'
[17:29:26.505]   - Field: 'conditions'
[17:29:26.505]   - Field: 'persistent'
[17:29:26.506]   - Field: 'expr'
[17:29:26.506]   - Field: 'uuid'
[17:29:26.506]   - Field: 'seed'
[17:29:26.507]   - Field: 'version'
[17:29:26.507]   - Field: 'result'
[17:29:26.507]   - Field: 'asynchronous'
[17:29:26.507]   - Field: 'calls'
[17:29:26.508]   - Field: 'globals'
[17:29:26.508]   - Field: 'stdout'
[17:29:26.508]   - Field: 'earlySignal'
[17:29:26.509]   - Field: 'lazy'
[17:29:26.509]   - Field: 'state'
[17:29:26.509] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:26.510] - Launch lazy future ...
[17:29:26.510] Packages needed by the future expression (n = 0): <none>
[17:29:26.511] Packages needed by future strategies (n = 0): <none>
[17:29:26.512] {
[17:29:26.512]     {
[17:29:26.512]         {
[17:29:26.512]             ...future.startTime <- base::Sys.time()
[17:29:26.512]             {
[17:29:26.512]                 {
[17:29:26.512]                   {
[17:29:26.512]                     {
[17:29:26.512]                       base::local({
[17:29:26.512]                         has_future <- base::requireNamespace("future", 
[17:29:26.512]                           quietly = TRUE)
[17:29:26.512]                         if (has_future) {
[17:29:26.512]                           ns <- base::getNamespace("future")
[17:29:26.512]                           version <- ns[[".package"]][["version"]]
[17:29:26.512]                           if (is.null(version)) 
[17:29:26.512]                             version <- utils::packageVersion("future")
[17:29:26.512]                         }
[17:29:26.512]                         else {
[17:29:26.512]                           version <- NULL
[17:29:26.512]                         }
[17:29:26.512]                         if (!has_future || version < "1.8.0") {
[17:29:26.512]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:26.512]                             "", base::R.version$version.string), 
[17:29:26.512]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:26.512]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:26.512]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:26.512]                               "release", "version")], collapse = " "), 
[17:29:26.512]                             hostname = base::Sys.info()[["nodename"]])
[17:29:26.512]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:26.512]                             info)
[17:29:26.512]                           info <- base::paste(info, collapse = "; ")
[17:29:26.512]                           if (!has_future) {
[17:29:26.512]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:26.512]                               info)
[17:29:26.512]                           }
[17:29:26.512]                           else {
[17:29:26.512]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:26.512]                               info, version)
[17:29:26.512]                           }
[17:29:26.512]                           base::stop(msg)
[17:29:26.512]                         }
[17:29:26.512]                       })
[17:29:26.512]                     }
[17:29:26.512]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:26.512]                     base::options(mc.cores = 1L)
[17:29:26.512]                   }
[17:29:26.512]                   ...future.strategy.old <- future::plan("list")
[17:29:26.512]                   options(future.plan = NULL)
[17:29:26.512]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:26.512]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:26.512]                 }
[17:29:26.512]                 ...future.workdir <- getwd()
[17:29:26.512]             }
[17:29:26.512]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:26.512]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:26.512]         }
[17:29:26.512]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:26.512]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:26.512]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:26.512]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:26.512]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:26.512]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:26.512]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:26.512]             base::names(...future.oldOptions))
[17:29:26.512]     }
[17:29:26.512]     if (FALSE) {
[17:29:26.512]     }
[17:29:26.512]     else {
[17:29:26.512]         if (TRUE) {
[17:29:26.512]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:26.512]                 open = "w")
[17:29:26.512]         }
[17:29:26.512]         else {
[17:29:26.512]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:26.512]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:26.512]         }
[17:29:26.512]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:26.512]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:26.512]             base::sink(type = "output", split = FALSE)
[17:29:26.512]             base::close(...future.stdout)
[17:29:26.512]         }, add = TRUE)
[17:29:26.512]     }
[17:29:26.512]     ...future.frame <- base::sys.nframe()
[17:29:26.512]     ...future.conditions <- base::list()
[17:29:26.512]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:26.512]     if (FALSE) {
[17:29:26.512]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:26.512]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:26.512]     }
[17:29:26.512]     ...future.result <- base::tryCatch({
[17:29:26.512]         base::withCallingHandlers({
[17:29:26.512]             ...future.value <- base::withVisible(base::local({
[17:29:26.512]                 ...future.makeSendCondition <- base::local({
[17:29:26.512]                   sendCondition <- NULL
[17:29:26.512]                   function(frame = 1L) {
[17:29:26.512]                     if (is.function(sendCondition)) 
[17:29:26.512]                       return(sendCondition)
[17:29:26.512]                     ns <- getNamespace("parallel")
[17:29:26.512]                     if (exists("sendData", mode = "function", 
[17:29:26.512]                       envir = ns)) {
[17:29:26.512]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:26.512]                         envir = ns)
[17:29:26.512]                       envir <- sys.frame(frame)
[17:29:26.512]                       master <- NULL
[17:29:26.512]                       while (!identical(envir, .GlobalEnv) && 
[17:29:26.512]                         !identical(envir, emptyenv())) {
[17:29:26.512]                         if (exists("master", mode = "list", envir = envir, 
[17:29:26.512]                           inherits = FALSE)) {
[17:29:26.512]                           master <- get("master", mode = "list", 
[17:29:26.512]                             envir = envir, inherits = FALSE)
[17:29:26.512]                           if (inherits(master, c("SOCKnode", 
[17:29:26.512]                             "SOCK0node"))) {
[17:29:26.512]                             sendCondition <<- function(cond) {
[17:29:26.512]                               data <- list(type = "VALUE", value = cond, 
[17:29:26.512]                                 success = TRUE)
[17:29:26.512]                               parallel_sendData(master, data)
[17:29:26.512]                             }
[17:29:26.512]                             return(sendCondition)
[17:29:26.512]                           }
[17:29:26.512]                         }
[17:29:26.512]                         frame <- frame + 1L
[17:29:26.512]                         envir <- sys.frame(frame)
[17:29:26.512]                       }
[17:29:26.512]                     }
[17:29:26.512]                     sendCondition <<- function(cond) NULL
[17:29:26.512]                   }
[17:29:26.512]                 })
[17:29:26.512]                 withCallingHandlers({
[17:29:26.512]                   {
[17:29:26.512]                     1
[17:29:26.512]                   }
[17:29:26.512]                 }, immediateCondition = function(cond) {
[17:29:26.512]                   sendCondition <- ...future.makeSendCondition()
[17:29:26.512]                   sendCondition(cond)
[17:29:26.512]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.512]                   {
[17:29:26.512]                     inherits <- base::inherits
[17:29:26.512]                     invokeRestart <- base::invokeRestart
[17:29:26.512]                     is.null <- base::is.null
[17:29:26.512]                     muffled <- FALSE
[17:29:26.512]                     if (inherits(cond, "message")) {
[17:29:26.512]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:26.512]                       if (muffled) 
[17:29:26.512]                         invokeRestart("muffleMessage")
[17:29:26.512]                     }
[17:29:26.512]                     else if (inherits(cond, "warning")) {
[17:29:26.512]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:26.512]                       if (muffled) 
[17:29:26.512]                         invokeRestart("muffleWarning")
[17:29:26.512]                     }
[17:29:26.512]                     else if (inherits(cond, "condition")) {
[17:29:26.512]                       if (!is.null(pattern)) {
[17:29:26.512]                         computeRestarts <- base::computeRestarts
[17:29:26.512]                         grepl <- base::grepl
[17:29:26.512]                         restarts <- computeRestarts(cond)
[17:29:26.512]                         for (restart in restarts) {
[17:29:26.512]                           name <- restart$name
[17:29:26.512]                           if (is.null(name)) 
[17:29:26.512]                             next
[17:29:26.512]                           if (!grepl(pattern, name)) 
[17:29:26.512]                             next
[17:29:26.512]                           invokeRestart(restart)
[17:29:26.512]                           muffled <- TRUE
[17:29:26.512]                           break
[17:29:26.512]                         }
[17:29:26.512]                       }
[17:29:26.512]                     }
[17:29:26.512]                     invisible(muffled)
[17:29:26.512]                   }
[17:29:26.512]                   muffleCondition(cond)
[17:29:26.512]                 })
[17:29:26.512]             }))
[17:29:26.512]             future::FutureResult(value = ...future.value$value, 
[17:29:26.512]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:26.512]                   ...future.rng), globalenv = if (FALSE) 
[17:29:26.512]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:26.512]                     ...future.globalenv.names))
[17:29:26.512]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:26.512]         }, condition = base::local({
[17:29:26.512]             c <- base::c
[17:29:26.512]             inherits <- base::inherits
[17:29:26.512]             invokeRestart <- base::invokeRestart
[17:29:26.512]             length <- base::length
[17:29:26.512]             list <- base::list
[17:29:26.512]             seq.int <- base::seq.int
[17:29:26.512]             signalCondition <- base::signalCondition
[17:29:26.512]             sys.calls <- base::sys.calls
[17:29:26.512]             `[[` <- base::`[[`
[17:29:26.512]             `+` <- base::`+`
[17:29:26.512]             `<<-` <- base::`<<-`
[17:29:26.512]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:26.512]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:26.512]                   3L)]
[17:29:26.512]             }
[17:29:26.512]             function(cond) {
[17:29:26.512]                 is_error <- inherits(cond, "error")
[17:29:26.512]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:26.512]                   NULL)
[17:29:26.512]                 if (is_error) {
[17:29:26.512]                   sessionInformation <- function() {
[17:29:26.512]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:26.512]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:26.512]                       search = base::search(), system = base::Sys.info())
[17:29:26.512]                   }
[17:29:26.512]                   ...future.conditions[[length(...future.conditions) + 
[17:29:26.512]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:26.512]                     cond$call), session = sessionInformation(), 
[17:29:26.512]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:26.512]                   signalCondition(cond)
[17:29:26.512]                 }
[17:29:26.512]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:26.512]                 "immediateCondition"))) {
[17:29:26.512]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:26.512]                   ...future.conditions[[length(...future.conditions) + 
[17:29:26.512]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:26.512]                   if (TRUE && !signal) {
[17:29:26.512]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.512]                     {
[17:29:26.512]                       inherits <- base::inherits
[17:29:26.512]                       invokeRestart <- base::invokeRestart
[17:29:26.512]                       is.null <- base::is.null
[17:29:26.512]                       muffled <- FALSE
[17:29:26.512]                       if (inherits(cond, "message")) {
[17:29:26.512]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:26.512]                         if (muffled) 
[17:29:26.512]                           invokeRestart("muffleMessage")
[17:29:26.512]                       }
[17:29:26.512]                       else if (inherits(cond, "warning")) {
[17:29:26.512]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:26.512]                         if (muffled) 
[17:29:26.512]                           invokeRestart("muffleWarning")
[17:29:26.512]                       }
[17:29:26.512]                       else if (inherits(cond, "condition")) {
[17:29:26.512]                         if (!is.null(pattern)) {
[17:29:26.512]                           computeRestarts <- base::computeRestarts
[17:29:26.512]                           grepl <- base::grepl
[17:29:26.512]                           restarts <- computeRestarts(cond)
[17:29:26.512]                           for (restart in restarts) {
[17:29:26.512]                             name <- restart$name
[17:29:26.512]                             if (is.null(name)) 
[17:29:26.512]                               next
[17:29:26.512]                             if (!grepl(pattern, name)) 
[17:29:26.512]                               next
[17:29:26.512]                             invokeRestart(restart)
[17:29:26.512]                             muffled <- TRUE
[17:29:26.512]                             break
[17:29:26.512]                           }
[17:29:26.512]                         }
[17:29:26.512]                       }
[17:29:26.512]                       invisible(muffled)
[17:29:26.512]                     }
[17:29:26.512]                     muffleCondition(cond, pattern = "^muffle")
[17:29:26.512]                   }
[17:29:26.512]                 }
[17:29:26.512]                 else {
[17:29:26.512]                   if (TRUE) {
[17:29:26.512]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.512]                     {
[17:29:26.512]                       inherits <- base::inherits
[17:29:26.512]                       invokeRestart <- base::invokeRestart
[17:29:26.512]                       is.null <- base::is.null
[17:29:26.512]                       muffled <- FALSE
[17:29:26.512]                       if (inherits(cond, "message")) {
[17:29:26.512]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:26.512]                         if (muffled) 
[17:29:26.512]                           invokeRestart("muffleMessage")
[17:29:26.512]                       }
[17:29:26.512]                       else if (inherits(cond, "warning")) {
[17:29:26.512]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:26.512]                         if (muffled) 
[17:29:26.512]                           invokeRestart("muffleWarning")
[17:29:26.512]                       }
[17:29:26.512]                       else if (inherits(cond, "condition")) {
[17:29:26.512]                         if (!is.null(pattern)) {
[17:29:26.512]                           computeRestarts <- base::computeRestarts
[17:29:26.512]                           grepl <- base::grepl
[17:29:26.512]                           restarts <- computeRestarts(cond)
[17:29:26.512]                           for (restart in restarts) {
[17:29:26.512]                             name <- restart$name
[17:29:26.512]                             if (is.null(name)) 
[17:29:26.512]                               next
[17:29:26.512]                             if (!grepl(pattern, name)) 
[17:29:26.512]                               next
[17:29:26.512]                             invokeRestart(restart)
[17:29:26.512]                             muffled <- TRUE
[17:29:26.512]                             break
[17:29:26.512]                           }
[17:29:26.512]                         }
[17:29:26.512]                       }
[17:29:26.512]                       invisible(muffled)
[17:29:26.512]                     }
[17:29:26.512]                     muffleCondition(cond, pattern = "^muffle")
[17:29:26.512]                   }
[17:29:26.512]                 }
[17:29:26.512]             }
[17:29:26.512]         }))
[17:29:26.512]     }, error = function(ex) {
[17:29:26.512]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:26.512]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:26.512]                 ...future.rng), started = ...future.startTime, 
[17:29:26.512]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:26.512]             version = "1.8"), class = "FutureResult")
[17:29:26.512]     }, finally = {
[17:29:26.512]         if (!identical(...future.workdir, getwd())) 
[17:29:26.512]             setwd(...future.workdir)
[17:29:26.512]         {
[17:29:26.512]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:26.512]                 ...future.oldOptions$nwarnings <- NULL
[17:29:26.512]             }
[17:29:26.512]             base::options(...future.oldOptions)
[17:29:26.512]             if (.Platform$OS.type == "windows") {
[17:29:26.512]                 old_names <- names(...future.oldEnvVars)
[17:29:26.512]                 envs <- base::Sys.getenv()
[17:29:26.512]                 names <- names(envs)
[17:29:26.512]                 common <- intersect(names, old_names)
[17:29:26.512]                 added <- setdiff(names, old_names)
[17:29:26.512]                 removed <- setdiff(old_names, names)
[17:29:26.512]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:26.512]                   envs[common]]
[17:29:26.512]                 NAMES <- toupper(changed)
[17:29:26.512]                 args <- list()
[17:29:26.512]                 for (kk in seq_along(NAMES)) {
[17:29:26.512]                   name <- changed[[kk]]
[17:29:26.512]                   NAME <- NAMES[[kk]]
[17:29:26.512]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.512]                     next
[17:29:26.512]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:26.512]                 }
[17:29:26.512]                 NAMES <- toupper(added)
[17:29:26.512]                 for (kk in seq_along(NAMES)) {
[17:29:26.512]                   name <- added[[kk]]
[17:29:26.512]                   NAME <- NAMES[[kk]]
[17:29:26.512]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.512]                     next
[17:29:26.512]                   args[[name]] <- ""
[17:29:26.512]                 }
[17:29:26.512]                 NAMES <- toupper(removed)
[17:29:26.512]                 for (kk in seq_along(NAMES)) {
[17:29:26.512]                   name <- removed[[kk]]
[17:29:26.512]                   NAME <- NAMES[[kk]]
[17:29:26.512]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.512]                     next
[17:29:26.512]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:26.512]                 }
[17:29:26.512]                 if (length(args) > 0) 
[17:29:26.512]                   base::do.call(base::Sys.setenv, args = args)
[17:29:26.512]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:26.512]             }
[17:29:26.512]             else {
[17:29:26.512]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:26.512]             }
[17:29:26.512]             {
[17:29:26.512]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:26.512]                   0L) {
[17:29:26.512]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:26.512]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:26.512]                   base::options(opts)
[17:29:26.512]                 }
[17:29:26.512]                 {
[17:29:26.512]                   {
[17:29:26.512]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:26.512]                     NULL
[17:29:26.512]                   }
[17:29:26.512]                   options(future.plan = NULL)
[17:29:26.512]                   if (is.na(NA_character_)) 
[17:29:26.512]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:26.512]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:26.512]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:26.512]                     .init = FALSE)
[17:29:26.512]                 }
[17:29:26.512]             }
[17:29:26.512]         }
[17:29:26.512]     })
[17:29:26.512]     if (TRUE) {
[17:29:26.512]         base::sink(type = "output", split = FALSE)
[17:29:26.512]         if (TRUE) {
[17:29:26.512]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:26.512]         }
[17:29:26.512]         else {
[17:29:26.512]             ...future.result["stdout"] <- base::list(NULL)
[17:29:26.512]         }
[17:29:26.512]         base::close(...future.stdout)
[17:29:26.512]         ...future.stdout <- NULL
[17:29:26.512]     }
[17:29:26.512]     ...future.result$conditions <- ...future.conditions
[17:29:26.512]     ...future.result$finished <- base::Sys.time()
[17:29:26.512]     ...future.result
[17:29:26.512] }
[17:29:26.521] MultisessionFuture started
[17:29:26.521] - Launch lazy future ... done
[17:29:26.521] run() for 'MultisessionFuture' ... done
[17:29:26.522] getGlobalsAndPackages() ...
[17:29:26.522] Searching for globals...
[17:29:26.525] - globals found: [2] '{', 'Sys.sleep'
[17:29:26.525] Searching for globals ... DONE
[17:29:26.525] Resolving globals: FALSE
[17:29:26.526] 
[17:29:26.526] 
[17:29:26.526] getGlobalsAndPackages() ... DONE
[17:29:26.527] run() for 'Future' ...
[17:29:26.527] - state: 'created'
[17:29:26.528] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:26.546] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:26.546] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:26.547]   - Field: 'node'
[17:29:26.547]   - Field: 'label'
[17:29:26.547]   - Field: 'local'
[17:29:26.547]   - Field: 'owner'
[17:29:26.547]   - Field: 'envir'
[17:29:26.548]   - Field: 'workers'
[17:29:26.548]   - Field: 'packages'
[17:29:26.548]   - Field: 'gc'
[17:29:26.548]   - Field: 'conditions'
[17:29:26.548]   - Field: 'persistent'
[17:29:26.548]   - Field: 'expr'
[17:29:26.549]   - Field: 'uuid'
[17:29:26.549]   - Field: 'seed'
[17:29:26.549]   - Field: 'version'
[17:29:26.549]   - Field: 'result'
[17:29:26.549]   - Field: 'asynchronous'
[17:29:26.549]   - Field: 'calls'
[17:29:26.550]   - Field: 'globals'
[17:29:26.550]   - Field: 'stdout'
[17:29:26.550]   - Field: 'earlySignal'
[17:29:26.550]   - Field: 'lazy'
[17:29:26.550]   - Field: 'state'
[17:29:26.551] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:26.551] - Launch lazy future ...
[17:29:26.551] Packages needed by the future expression (n = 0): <none>
[17:29:26.552] Packages needed by future strategies (n = 0): <none>
[17:29:26.552] {
[17:29:26.552]     {
[17:29:26.552]         {
[17:29:26.552]             ...future.startTime <- base::Sys.time()
[17:29:26.552]             {
[17:29:26.552]                 {
[17:29:26.552]                   {
[17:29:26.552]                     {
[17:29:26.552]                       base::local({
[17:29:26.552]                         has_future <- base::requireNamespace("future", 
[17:29:26.552]                           quietly = TRUE)
[17:29:26.552]                         if (has_future) {
[17:29:26.552]                           ns <- base::getNamespace("future")
[17:29:26.552]                           version <- ns[[".package"]][["version"]]
[17:29:26.552]                           if (is.null(version)) 
[17:29:26.552]                             version <- utils::packageVersion("future")
[17:29:26.552]                         }
[17:29:26.552]                         else {
[17:29:26.552]                           version <- NULL
[17:29:26.552]                         }
[17:29:26.552]                         if (!has_future || version < "1.8.0") {
[17:29:26.552]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:26.552]                             "", base::R.version$version.string), 
[17:29:26.552]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:26.552]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:26.552]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:26.552]                               "release", "version")], collapse = " "), 
[17:29:26.552]                             hostname = base::Sys.info()[["nodename"]])
[17:29:26.552]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:26.552]                             info)
[17:29:26.552]                           info <- base::paste(info, collapse = "; ")
[17:29:26.552]                           if (!has_future) {
[17:29:26.552]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:26.552]                               info)
[17:29:26.552]                           }
[17:29:26.552]                           else {
[17:29:26.552]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:26.552]                               info, version)
[17:29:26.552]                           }
[17:29:26.552]                           base::stop(msg)
[17:29:26.552]                         }
[17:29:26.552]                       })
[17:29:26.552]                     }
[17:29:26.552]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:26.552]                     base::options(mc.cores = 1L)
[17:29:26.552]                   }
[17:29:26.552]                   ...future.strategy.old <- future::plan("list")
[17:29:26.552]                   options(future.plan = NULL)
[17:29:26.552]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:26.552]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:26.552]                 }
[17:29:26.552]                 ...future.workdir <- getwd()
[17:29:26.552]             }
[17:29:26.552]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:26.552]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:26.552]         }
[17:29:26.552]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:26.552]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:26.552]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:26.552]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:26.552]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:26.552]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:26.552]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:26.552]             base::names(...future.oldOptions))
[17:29:26.552]     }
[17:29:26.552]     if (FALSE) {
[17:29:26.552]     }
[17:29:26.552]     else {
[17:29:26.552]         if (TRUE) {
[17:29:26.552]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:26.552]                 open = "w")
[17:29:26.552]         }
[17:29:26.552]         else {
[17:29:26.552]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:26.552]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:26.552]         }
[17:29:26.552]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:26.552]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:26.552]             base::sink(type = "output", split = FALSE)
[17:29:26.552]             base::close(...future.stdout)
[17:29:26.552]         }, add = TRUE)
[17:29:26.552]     }
[17:29:26.552]     ...future.frame <- base::sys.nframe()
[17:29:26.552]     ...future.conditions <- base::list()
[17:29:26.552]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:26.552]     if (FALSE) {
[17:29:26.552]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:26.552]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:26.552]     }
[17:29:26.552]     ...future.result <- base::tryCatch({
[17:29:26.552]         base::withCallingHandlers({
[17:29:26.552]             ...future.value <- base::withVisible(base::local({
[17:29:26.552]                 ...future.makeSendCondition <- base::local({
[17:29:26.552]                   sendCondition <- NULL
[17:29:26.552]                   function(frame = 1L) {
[17:29:26.552]                     if (is.function(sendCondition)) 
[17:29:26.552]                       return(sendCondition)
[17:29:26.552]                     ns <- getNamespace("parallel")
[17:29:26.552]                     if (exists("sendData", mode = "function", 
[17:29:26.552]                       envir = ns)) {
[17:29:26.552]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:26.552]                         envir = ns)
[17:29:26.552]                       envir <- sys.frame(frame)
[17:29:26.552]                       master <- NULL
[17:29:26.552]                       while (!identical(envir, .GlobalEnv) && 
[17:29:26.552]                         !identical(envir, emptyenv())) {
[17:29:26.552]                         if (exists("master", mode = "list", envir = envir, 
[17:29:26.552]                           inherits = FALSE)) {
[17:29:26.552]                           master <- get("master", mode = "list", 
[17:29:26.552]                             envir = envir, inherits = FALSE)
[17:29:26.552]                           if (inherits(master, c("SOCKnode", 
[17:29:26.552]                             "SOCK0node"))) {
[17:29:26.552]                             sendCondition <<- function(cond) {
[17:29:26.552]                               data <- list(type = "VALUE", value = cond, 
[17:29:26.552]                                 success = TRUE)
[17:29:26.552]                               parallel_sendData(master, data)
[17:29:26.552]                             }
[17:29:26.552]                             return(sendCondition)
[17:29:26.552]                           }
[17:29:26.552]                         }
[17:29:26.552]                         frame <- frame + 1L
[17:29:26.552]                         envir <- sys.frame(frame)
[17:29:26.552]                       }
[17:29:26.552]                     }
[17:29:26.552]                     sendCondition <<- function(cond) NULL
[17:29:26.552]                   }
[17:29:26.552]                 })
[17:29:26.552]                 withCallingHandlers({
[17:29:26.552]                   {
[17:29:26.552]                     Sys.sleep(0.5)
[17:29:26.552]                     2
[17:29:26.552]                   }
[17:29:26.552]                 }, immediateCondition = function(cond) {
[17:29:26.552]                   sendCondition <- ...future.makeSendCondition()
[17:29:26.552]                   sendCondition(cond)
[17:29:26.552]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.552]                   {
[17:29:26.552]                     inherits <- base::inherits
[17:29:26.552]                     invokeRestart <- base::invokeRestart
[17:29:26.552]                     is.null <- base::is.null
[17:29:26.552]                     muffled <- FALSE
[17:29:26.552]                     if (inherits(cond, "message")) {
[17:29:26.552]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:26.552]                       if (muffled) 
[17:29:26.552]                         invokeRestart("muffleMessage")
[17:29:26.552]                     }
[17:29:26.552]                     else if (inherits(cond, "warning")) {
[17:29:26.552]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:26.552]                       if (muffled) 
[17:29:26.552]                         invokeRestart("muffleWarning")
[17:29:26.552]                     }
[17:29:26.552]                     else if (inherits(cond, "condition")) {
[17:29:26.552]                       if (!is.null(pattern)) {
[17:29:26.552]                         computeRestarts <- base::computeRestarts
[17:29:26.552]                         grepl <- base::grepl
[17:29:26.552]                         restarts <- computeRestarts(cond)
[17:29:26.552]                         for (restart in restarts) {
[17:29:26.552]                           name <- restart$name
[17:29:26.552]                           if (is.null(name)) 
[17:29:26.552]                             next
[17:29:26.552]                           if (!grepl(pattern, name)) 
[17:29:26.552]                             next
[17:29:26.552]                           invokeRestart(restart)
[17:29:26.552]                           muffled <- TRUE
[17:29:26.552]                           break
[17:29:26.552]                         }
[17:29:26.552]                       }
[17:29:26.552]                     }
[17:29:26.552]                     invisible(muffled)
[17:29:26.552]                   }
[17:29:26.552]                   muffleCondition(cond)
[17:29:26.552]                 })
[17:29:26.552]             }))
[17:29:26.552]             future::FutureResult(value = ...future.value$value, 
[17:29:26.552]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:26.552]                   ...future.rng), globalenv = if (FALSE) 
[17:29:26.552]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:26.552]                     ...future.globalenv.names))
[17:29:26.552]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:26.552]         }, condition = base::local({
[17:29:26.552]             c <- base::c
[17:29:26.552]             inherits <- base::inherits
[17:29:26.552]             invokeRestart <- base::invokeRestart
[17:29:26.552]             length <- base::length
[17:29:26.552]             list <- base::list
[17:29:26.552]             seq.int <- base::seq.int
[17:29:26.552]             signalCondition <- base::signalCondition
[17:29:26.552]             sys.calls <- base::sys.calls
[17:29:26.552]             `[[` <- base::`[[`
[17:29:26.552]             `+` <- base::`+`
[17:29:26.552]             `<<-` <- base::`<<-`
[17:29:26.552]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:26.552]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:26.552]                   3L)]
[17:29:26.552]             }
[17:29:26.552]             function(cond) {
[17:29:26.552]                 is_error <- inherits(cond, "error")
[17:29:26.552]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:26.552]                   NULL)
[17:29:26.552]                 if (is_error) {
[17:29:26.552]                   sessionInformation <- function() {
[17:29:26.552]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:26.552]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:26.552]                       search = base::search(), system = base::Sys.info())
[17:29:26.552]                   }
[17:29:26.552]                   ...future.conditions[[length(...future.conditions) + 
[17:29:26.552]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:26.552]                     cond$call), session = sessionInformation(), 
[17:29:26.552]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:26.552]                   signalCondition(cond)
[17:29:26.552]                 }
[17:29:26.552]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:26.552]                 "immediateCondition"))) {
[17:29:26.552]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:26.552]                   ...future.conditions[[length(...future.conditions) + 
[17:29:26.552]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:26.552]                   if (TRUE && !signal) {
[17:29:26.552]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.552]                     {
[17:29:26.552]                       inherits <- base::inherits
[17:29:26.552]                       invokeRestart <- base::invokeRestart
[17:29:26.552]                       is.null <- base::is.null
[17:29:26.552]                       muffled <- FALSE
[17:29:26.552]                       if (inherits(cond, "message")) {
[17:29:26.552]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:26.552]                         if (muffled) 
[17:29:26.552]                           invokeRestart("muffleMessage")
[17:29:26.552]                       }
[17:29:26.552]                       else if (inherits(cond, "warning")) {
[17:29:26.552]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:26.552]                         if (muffled) 
[17:29:26.552]                           invokeRestart("muffleWarning")
[17:29:26.552]                       }
[17:29:26.552]                       else if (inherits(cond, "condition")) {
[17:29:26.552]                         if (!is.null(pattern)) {
[17:29:26.552]                           computeRestarts <- base::computeRestarts
[17:29:26.552]                           grepl <- base::grepl
[17:29:26.552]                           restarts <- computeRestarts(cond)
[17:29:26.552]                           for (restart in restarts) {
[17:29:26.552]                             name <- restart$name
[17:29:26.552]                             if (is.null(name)) 
[17:29:26.552]                               next
[17:29:26.552]                             if (!grepl(pattern, name)) 
[17:29:26.552]                               next
[17:29:26.552]                             invokeRestart(restart)
[17:29:26.552]                             muffled <- TRUE
[17:29:26.552]                             break
[17:29:26.552]                           }
[17:29:26.552]                         }
[17:29:26.552]                       }
[17:29:26.552]                       invisible(muffled)
[17:29:26.552]                     }
[17:29:26.552]                     muffleCondition(cond, pattern = "^muffle")
[17:29:26.552]                   }
[17:29:26.552]                 }
[17:29:26.552]                 else {
[17:29:26.552]                   if (TRUE) {
[17:29:26.552]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.552]                     {
[17:29:26.552]                       inherits <- base::inherits
[17:29:26.552]                       invokeRestart <- base::invokeRestart
[17:29:26.552]                       is.null <- base::is.null
[17:29:26.552]                       muffled <- FALSE
[17:29:26.552]                       if (inherits(cond, "message")) {
[17:29:26.552]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:26.552]                         if (muffled) 
[17:29:26.552]                           invokeRestart("muffleMessage")
[17:29:26.552]                       }
[17:29:26.552]                       else if (inherits(cond, "warning")) {
[17:29:26.552]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:26.552]                         if (muffled) 
[17:29:26.552]                           invokeRestart("muffleWarning")
[17:29:26.552]                       }
[17:29:26.552]                       else if (inherits(cond, "condition")) {
[17:29:26.552]                         if (!is.null(pattern)) {
[17:29:26.552]                           computeRestarts <- base::computeRestarts
[17:29:26.552]                           grepl <- base::grepl
[17:29:26.552]                           restarts <- computeRestarts(cond)
[17:29:26.552]                           for (restart in restarts) {
[17:29:26.552]                             name <- restart$name
[17:29:26.552]                             if (is.null(name)) 
[17:29:26.552]                               next
[17:29:26.552]                             if (!grepl(pattern, name)) 
[17:29:26.552]                               next
[17:29:26.552]                             invokeRestart(restart)
[17:29:26.552]                             muffled <- TRUE
[17:29:26.552]                             break
[17:29:26.552]                           }
[17:29:26.552]                         }
[17:29:26.552]                       }
[17:29:26.552]                       invisible(muffled)
[17:29:26.552]                     }
[17:29:26.552]                     muffleCondition(cond, pattern = "^muffle")
[17:29:26.552]                   }
[17:29:26.552]                 }
[17:29:26.552]             }
[17:29:26.552]         }))
[17:29:26.552]     }, error = function(ex) {
[17:29:26.552]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:26.552]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:26.552]                 ...future.rng), started = ...future.startTime, 
[17:29:26.552]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:26.552]             version = "1.8"), class = "FutureResult")
[17:29:26.552]     }, finally = {
[17:29:26.552]         if (!identical(...future.workdir, getwd())) 
[17:29:26.552]             setwd(...future.workdir)
[17:29:26.552]         {
[17:29:26.552]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:26.552]                 ...future.oldOptions$nwarnings <- NULL
[17:29:26.552]             }
[17:29:26.552]             base::options(...future.oldOptions)
[17:29:26.552]             if (.Platform$OS.type == "windows") {
[17:29:26.552]                 old_names <- names(...future.oldEnvVars)
[17:29:26.552]                 envs <- base::Sys.getenv()
[17:29:26.552]                 names <- names(envs)
[17:29:26.552]                 common <- intersect(names, old_names)
[17:29:26.552]                 added <- setdiff(names, old_names)
[17:29:26.552]                 removed <- setdiff(old_names, names)
[17:29:26.552]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:26.552]                   envs[common]]
[17:29:26.552]                 NAMES <- toupper(changed)
[17:29:26.552]                 args <- list()
[17:29:26.552]                 for (kk in seq_along(NAMES)) {
[17:29:26.552]                   name <- changed[[kk]]
[17:29:26.552]                   NAME <- NAMES[[kk]]
[17:29:26.552]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.552]                     next
[17:29:26.552]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:26.552]                 }
[17:29:26.552]                 NAMES <- toupper(added)
[17:29:26.552]                 for (kk in seq_along(NAMES)) {
[17:29:26.552]                   name <- added[[kk]]
[17:29:26.552]                   NAME <- NAMES[[kk]]
[17:29:26.552]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.552]                     next
[17:29:26.552]                   args[[name]] <- ""
[17:29:26.552]                 }
[17:29:26.552]                 NAMES <- toupper(removed)
[17:29:26.552]                 for (kk in seq_along(NAMES)) {
[17:29:26.552]                   name <- removed[[kk]]
[17:29:26.552]                   NAME <- NAMES[[kk]]
[17:29:26.552]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.552]                     next
[17:29:26.552]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:26.552]                 }
[17:29:26.552]                 if (length(args) > 0) 
[17:29:26.552]                   base::do.call(base::Sys.setenv, args = args)
[17:29:26.552]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:26.552]             }
[17:29:26.552]             else {
[17:29:26.552]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:26.552]             }
[17:29:26.552]             {
[17:29:26.552]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:26.552]                   0L) {
[17:29:26.552]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:26.552]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:26.552]                   base::options(opts)
[17:29:26.552]                 }
[17:29:26.552]                 {
[17:29:26.552]                   {
[17:29:26.552]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:26.552]                     NULL
[17:29:26.552]                   }
[17:29:26.552]                   options(future.plan = NULL)
[17:29:26.552]                   if (is.na(NA_character_)) 
[17:29:26.552]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:26.552]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:26.552]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:26.552]                     .init = FALSE)
[17:29:26.552]                 }
[17:29:26.552]             }
[17:29:26.552]         }
[17:29:26.552]     })
[17:29:26.552]     if (TRUE) {
[17:29:26.552]         base::sink(type = "output", split = FALSE)
[17:29:26.552]         if (TRUE) {
[17:29:26.552]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:26.552]         }
[17:29:26.552]         else {
[17:29:26.552]             ...future.result["stdout"] <- base::list(NULL)
[17:29:26.552]         }
[17:29:26.552]         base::close(...future.stdout)
[17:29:26.552]         ...future.stdout <- NULL
[17:29:26.552]     }
[17:29:26.552]     ...future.result$conditions <- ...future.conditions
[17:29:26.552]     ...future.result$finished <- base::Sys.time()
[17:29:26.552]     ...future.result
[17:29:26.552] }
[17:29:26.559] MultisessionFuture started
[17:29:26.559] - Launch lazy future ... done
[17:29:26.559] run() for 'MultisessionFuture' ... done
[17:29:26.560] getGlobalsAndPackages() ...
[17:29:26.560] Searching for globals...
[17:29:26.561] - globals found: [1] '{'
[17:29:26.561] Searching for globals ... DONE
[17:29:26.561] Resolving globals: FALSE
[17:29:26.562] 
[17:29:26.562] 
[17:29:26.562] getGlobalsAndPackages() ... DONE
[17:29:26.562] run() for 'Future' ...
[17:29:26.562] - state: 'created'
[17:29:26.563] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:26.582] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:26.582] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:26.583]   - Field: 'node'
[17:29:26.583]   - Field: 'label'
[17:29:26.583]   - Field: 'local'
[17:29:26.584]   - Field: 'owner'
[17:29:26.584]   - Field: 'envir'
[17:29:26.584]   - Field: 'workers'
[17:29:26.585]   - Field: 'packages'
[17:29:26.585]   - Field: 'gc'
[17:29:26.585]   - Field: 'conditions'
[17:29:26.586]   - Field: 'persistent'
[17:29:26.586]   - Field: 'expr'
[17:29:26.586]   - Field: 'uuid'
[17:29:26.587]   - Field: 'seed'
[17:29:26.587]   - Field: 'version'
[17:29:26.587]   - Field: 'result'
[17:29:26.588]   - Field: 'asynchronous'
[17:29:26.588]   - Field: 'calls'
[17:29:26.588]   - Field: 'globals'
[17:29:26.589]   - Field: 'stdout'
[17:29:26.589]   - Field: 'earlySignal'
[17:29:26.589]   - Field: 'lazy'
[17:29:26.589]   - Field: 'state'
[17:29:26.590] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:26.590] - Launch lazy future ...
[17:29:26.591] Packages needed by the future expression (n = 0): <none>
[17:29:26.591] Packages needed by future strategies (n = 0): <none>
[17:29:26.592] {
[17:29:26.592]     {
[17:29:26.592]         {
[17:29:26.592]             ...future.startTime <- base::Sys.time()
[17:29:26.592]             {
[17:29:26.592]                 {
[17:29:26.592]                   {
[17:29:26.592]                     {
[17:29:26.592]                       base::local({
[17:29:26.592]                         has_future <- base::requireNamespace("future", 
[17:29:26.592]                           quietly = TRUE)
[17:29:26.592]                         if (has_future) {
[17:29:26.592]                           ns <- base::getNamespace("future")
[17:29:26.592]                           version <- ns[[".package"]][["version"]]
[17:29:26.592]                           if (is.null(version)) 
[17:29:26.592]                             version <- utils::packageVersion("future")
[17:29:26.592]                         }
[17:29:26.592]                         else {
[17:29:26.592]                           version <- NULL
[17:29:26.592]                         }
[17:29:26.592]                         if (!has_future || version < "1.8.0") {
[17:29:26.592]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:26.592]                             "", base::R.version$version.string), 
[17:29:26.592]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:26.592]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:26.592]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:26.592]                               "release", "version")], collapse = " "), 
[17:29:26.592]                             hostname = base::Sys.info()[["nodename"]])
[17:29:26.592]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:26.592]                             info)
[17:29:26.592]                           info <- base::paste(info, collapse = "; ")
[17:29:26.592]                           if (!has_future) {
[17:29:26.592]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:26.592]                               info)
[17:29:26.592]                           }
[17:29:26.592]                           else {
[17:29:26.592]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:26.592]                               info, version)
[17:29:26.592]                           }
[17:29:26.592]                           base::stop(msg)
[17:29:26.592]                         }
[17:29:26.592]                       })
[17:29:26.592]                     }
[17:29:26.592]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:26.592]                     base::options(mc.cores = 1L)
[17:29:26.592]                   }
[17:29:26.592]                   ...future.strategy.old <- future::plan("list")
[17:29:26.592]                   options(future.plan = NULL)
[17:29:26.592]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:26.592]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:26.592]                 }
[17:29:26.592]                 ...future.workdir <- getwd()
[17:29:26.592]             }
[17:29:26.592]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:26.592]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:26.592]         }
[17:29:26.592]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:26.592]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:26.592]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:26.592]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:26.592]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:26.592]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:26.592]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:26.592]             base::names(...future.oldOptions))
[17:29:26.592]     }
[17:29:26.592]     if (FALSE) {
[17:29:26.592]     }
[17:29:26.592]     else {
[17:29:26.592]         if (TRUE) {
[17:29:26.592]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:26.592]                 open = "w")
[17:29:26.592]         }
[17:29:26.592]         else {
[17:29:26.592]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:26.592]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:26.592]         }
[17:29:26.592]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:26.592]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:26.592]             base::sink(type = "output", split = FALSE)
[17:29:26.592]             base::close(...future.stdout)
[17:29:26.592]         }, add = TRUE)
[17:29:26.592]     }
[17:29:26.592]     ...future.frame <- base::sys.nframe()
[17:29:26.592]     ...future.conditions <- base::list()
[17:29:26.592]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:26.592]     if (FALSE) {
[17:29:26.592]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:26.592]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:26.592]     }
[17:29:26.592]     ...future.result <- base::tryCatch({
[17:29:26.592]         base::withCallingHandlers({
[17:29:26.592]             ...future.value <- base::withVisible(base::local({
[17:29:26.592]                 ...future.makeSendCondition <- base::local({
[17:29:26.592]                   sendCondition <- NULL
[17:29:26.592]                   function(frame = 1L) {
[17:29:26.592]                     if (is.function(sendCondition)) 
[17:29:26.592]                       return(sendCondition)
[17:29:26.592]                     ns <- getNamespace("parallel")
[17:29:26.592]                     if (exists("sendData", mode = "function", 
[17:29:26.592]                       envir = ns)) {
[17:29:26.592]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:26.592]                         envir = ns)
[17:29:26.592]                       envir <- sys.frame(frame)
[17:29:26.592]                       master <- NULL
[17:29:26.592]                       while (!identical(envir, .GlobalEnv) && 
[17:29:26.592]                         !identical(envir, emptyenv())) {
[17:29:26.592]                         if (exists("master", mode = "list", envir = envir, 
[17:29:26.592]                           inherits = FALSE)) {
[17:29:26.592]                           master <- get("master", mode = "list", 
[17:29:26.592]                             envir = envir, inherits = FALSE)
[17:29:26.592]                           if (inherits(master, c("SOCKnode", 
[17:29:26.592]                             "SOCK0node"))) {
[17:29:26.592]                             sendCondition <<- function(cond) {
[17:29:26.592]                               data <- list(type = "VALUE", value = cond, 
[17:29:26.592]                                 success = TRUE)
[17:29:26.592]                               parallel_sendData(master, data)
[17:29:26.592]                             }
[17:29:26.592]                             return(sendCondition)
[17:29:26.592]                           }
[17:29:26.592]                         }
[17:29:26.592]                         frame <- frame + 1L
[17:29:26.592]                         envir <- sys.frame(frame)
[17:29:26.592]                       }
[17:29:26.592]                     }
[17:29:26.592]                     sendCondition <<- function(cond) NULL
[17:29:26.592]                   }
[17:29:26.592]                 })
[17:29:26.592]                 withCallingHandlers({
[17:29:26.592]                   {
[17:29:26.592]                     3
[17:29:26.592]                   }
[17:29:26.592]                 }, immediateCondition = function(cond) {
[17:29:26.592]                   sendCondition <- ...future.makeSendCondition()
[17:29:26.592]                   sendCondition(cond)
[17:29:26.592]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.592]                   {
[17:29:26.592]                     inherits <- base::inherits
[17:29:26.592]                     invokeRestart <- base::invokeRestart
[17:29:26.592]                     is.null <- base::is.null
[17:29:26.592]                     muffled <- FALSE
[17:29:26.592]                     if (inherits(cond, "message")) {
[17:29:26.592]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:26.592]                       if (muffled) 
[17:29:26.592]                         invokeRestart("muffleMessage")
[17:29:26.592]                     }
[17:29:26.592]                     else if (inherits(cond, "warning")) {
[17:29:26.592]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:26.592]                       if (muffled) 
[17:29:26.592]                         invokeRestart("muffleWarning")
[17:29:26.592]                     }
[17:29:26.592]                     else if (inherits(cond, "condition")) {
[17:29:26.592]                       if (!is.null(pattern)) {
[17:29:26.592]                         computeRestarts <- base::computeRestarts
[17:29:26.592]                         grepl <- base::grepl
[17:29:26.592]                         restarts <- computeRestarts(cond)
[17:29:26.592]                         for (restart in restarts) {
[17:29:26.592]                           name <- restart$name
[17:29:26.592]                           if (is.null(name)) 
[17:29:26.592]                             next
[17:29:26.592]                           if (!grepl(pattern, name)) 
[17:29:26.592]                             next
[17:29:26.592]                           invokeRestart(restart)
[17:29:26.592]                           muffled <- TRUE
[17:29:26.592]                           break
[17:29:26.592]                         }
[17:29:26.592]                       }
[17:29:26.592]                     }
[17:29:26.592]                     invisible(muffled)
[17:29:26.592]                   }
[17:29:26.592]                   muffleCondition(cond)
[17:29:26.592]                 })
[17:29:26.592]             }))
[17:29:26.592]             future::FutureResult(value = ...future.value$value, 
[17:29:26.592]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:26.592]                   ...future.rng), globalenv = if (FALSE) 
[17:29:26.592]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:26.592]                     ...future.globalenv.names))
[17:29:26.592]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:26.592]         }, condition = base::local({
[17:29:26.592]             c <- base::c
[17:29:26.592]             inherits <- base::inherits
[17:29:26.592]             invokeRestart <- base::invokeRestart
[17:29:26.592]             length <- base::length
[17:29:26.592]             list <- base::list
[17:29:26.592]             seq.int <- base::seq.int
[17:29:26.592]             signalCondition <- base::signalCondition
[17:29:26.592]             sys.calls <- base::sys.calls
[17:29:26.592]             `[[` <- base::`[[`
[17:29:26.592]             `+` <- base::`+`
[17:29:26.592]             `<<-` <- base::`<<-`
[17:29:26.592]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:26.592]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:26.592]                   3L)]
[17:29:26.592]             }
[17:29:26.592]             function(cond) {
[17:29:26.592]                 is_error <- inherits(cond, "error")
[17:29:26.592]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:26.592]                   NULL)
[17:29:26.592]                 if (is_error) {
[17:29:26.592]                   sessionInformation <- function() {
[17:29:26.592]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:26.592]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:26.592]                       search = base::search(), system = base::Sys.info())
[17:29:26.592]                   }
[17:29:26.592]                   ...future.conditions[[length(...future.conditions) + 
[17:29:26.592]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:26.592]                     cond$call), session = sessionInformation(), 
[17:29:26.592]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:26.592]                   signalCondition(cond)
[17:29:26.592]                 }
[17:29:26.592]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:26.592]                 "immediateCondition"))) {
[17:29:26.592]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:26.592]                   ...future.conditions[[length(...future.conditions) + 
[17:29:26.592]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:26.592]                   if (TRUE && !signal) {
[17:29:26.592]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.592]                     {
[17:29:26.592]                       inherits <- base::inherits
[17:29:26.592]                       invokeRestart <- base::invokeRestart
[17:29:26.592]                       is.null <- base::is.null
[17:29:26.592]                       muffled <- FALSE
[17:29:26.592]                       if (inherits(cond, "message")) {
[17:29:26.592]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:26.592]                         if (muffled) 
[17:29:26.592]                           invokeRestart("muffleMessage")
[17:29:26.592]                       }
[17:29:26.592]                       else if (inherits(cond, "warning")) {
[17:29:26.592]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:26.592]                         if (muffled) 
[17:29:26.592]                           invokeRestart("muffleWarning")
[17:29:26.592]                       }
[17:29:26.592]                       else if (inherits(cond, "condition")) {
[17:29:26.592]                         if (!is.null(pattern)) {
[17:29:26.592]                           computeRestarts <- base::computeRestarts
[17:29:26.592]                           grepl <- base::grepl
[17:29:26.592]                           restarts <- computeRestarts(cond)
[17:29:26.592]                           for (restart in restarts) {
[17:29:26.592]                             name <- restart$name
[17:29:26.592]                             if (is.null(name)) 
[17:29:26.592]                               next
[17:29:26.592]                             if (!grepl(pattern, name)) 
[17:29:26.592]                               next
[17:29:26.592]                             invokeRestart(restart)
[17:29:26.592]                             muffled <- TRUE
[17:29:26.592]                             break
[17:29:26.592]                           }
[17:29:26.592]                         }
[17:29:26.592]                       }
[17:29:26.592]                       invisible(muffled)
[17:29:26.592]                     }
[17:29:26.592]                     muffleCondition(cond, pattern = "^muffle")
[17:29:26.592]                   }
[17:29:26.592]                 }
[17:29:26.592]                 else {
[17:29:26.592]                   if (TRUE) {
[17:29:26.592]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:26.592]                     {
[17:29:26.592]                       inherits <- base::inherits
[17:29:26.592]                       invokeRestart <- base::invokeRestart
[17:29:26.592]                       is.null <- base::is.null
[17:29:26.592]                       muffled <- FALSE
[17:29:26.592]                       if (inherits(cond, "message")) {
[17:29:26.592]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:26.592]                         if (muffled) 
[17:29:26.592]                           invokeRestart("muffleMessage")
[17:29:26.592]                       }
[17:29:26.592]                       else if (inherits(cond, "warning")) {
[17:29:26.592]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:26.592]                         if (muffled) 
[17:29:26.592]                           invokeRestart("muffleWarning")
[17:29:26.592]                       }
[17:29:26.592]                       else if (inherits(cond, "condition")) {
[17:29:26.592]                         if (!is.null(pattern)) {
[17:29:26.592]                           computeRestarts <- base::computeRestarts
[17:29:26.592]                           grepl <- base::grepl
[17:29:26.592]                           restarts <- computeRestarts(cond)
[17:29:26.592]                           for (restart in restarts) {
[17:29:26.592]                             name <- restart$name
[17:29:26.592]                             if (is.null(name)) 
[17:29:26.592]                               next
[17:29:26.592]                             if (!grepl(pattern, name)) 
[17:29:26.592]                               next
[17:29:26.592]                             invokeRestart(restart)
[17:29:26.592]                             muffled <- TRUE
[17:29:26.592]                             break
[17:29:26.592]                           }
[17:29:26.592]                         }
[17:29:26.592]                       }
[17:29:26.592]                       invisible(muffled)
[17:29:26.592]                     }
[17:29:26.592]                     muffleCondition(cond, pattern = "^muffle")
[17:29:26.592]                   }
[17:29:26.592]                 }
[17:29:26.592]             }
[17:29:26.592]         }))
[17:29:26.592]     }, error = function(ex) {
[17:29:26.592]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:26.592]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:26.592]                 ...future.rng), started = ...future.startTime, 
[17:29:26.592]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:26.592]             version = "1.8"), class = "FutureResult")
[17:29:26.592]     }, finally = {
[17:29:26.592]         if (!identical(...future.workdir, getwd())) 
[17:29:26.592]             setwd(...future.workdir)
[17:29:26.592]         {
[17:29:26.592]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:26.592]                 ...future.oldOptions$nwarnings <- NULL
[17:29:26.592]             }
[17:29:26.592]             base::options(...future.oldOptions)
[17:29:26.592]             if (.Platform$OS.type == "windows") {
[17:29:26.592]                 old_names <- names(...future.oldEnvVars)
[17:29:26.592]                 envs <- base::Sys.getenv()
[17:29:26.592]                 names <- names(envs)
[17:29:26.592]                 common <- intersect(names, old_names)
[17:29:26.592]                 added <- setdiff(names, old_names)
[17:29:26.592]                 removed <- setdiff(old_names, names)
[17:29:26.592]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:26.592]                   envs[common]]
[17:29:26.592]                 NAMES <- toupper(changed)
[17:29:26.592]                 args <- list()
[17:29:26.592]                 for (kk in seq_along(NAMES)) {
[17:29:26.592]                   name <- changed[[kk]]
[17:29:26.592]                   NAME <- NAMES[[kk]]
[17:29:26.592]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.592]                     next
[17:29:26.592]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:26.592]                 }
[17:29:26.592]                 NAMES <- toupper(added)
[17:29:26.592]                 for (kk in seq_along(NAMES)) {
[17:29:26.592]                   name <- added[[kk]]
[17:29:26.592]                   NAME <- NAMES[[kk]]
[17:29:26.592]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.592]                     next
[17:29:26.592]                   args[[name]] <- ""
[17:29:26.592]                 }
[17:29:26.592]                 NAMES <- toupper(removed)
[17:29:26.592]                 for (kk in seq_along(NAMES)) {
[17:29:26.592]                   name <- removed[[kk]]
[17:29:26.592]                   NAME <- NAMES[[kk]]
[17:29:26.592]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:26.592]                     next
[17:29:26.592]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:26.592]                 }
[17:29:26.592]                 if (length(args) > 0) 
[17:29:26.592]                   base::do.call(base::Sys.setenv, args = args)
[17:29:26.592]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:26.592]             }
[17:29:26.592]             else {
[17:29:26.592]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:26.592]             }
[17:29:26.592]             {
[17:29:26.592]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:26.592]                   0L) {
[17:29:26.592]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:26.592]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:26.592]                   base::options(opts)
[17:29:26.592]                 }
[17:29:26.592]                 {
[17:29:26.592]                   {
[17:29:26.592]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:26.592]                     NULL
[17:29:26.592]                   }
[17:29:26.592]                   options(future.plan = NULL)
[17:29:26.592]                   if (is.na(NA_character_)) 
[17:29:26.592]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:26.592]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:26.592]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:26.592]                     .init = FALSE)
[17:29:26.592]                 }
[17:29:26.592]             }
[17:29:26.592]         }
[17:29:26.592]     })
[17:29:26.592]     if (TRUE) {
[17:29:26.592]         base::sink(type = "output", split = FALSE)
[17:29:26.592]         if (TRUE) {
[17:29:26.592]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:26.592]         }
[17:29:26.592]         else {
[17:29:26.592]             ...future.result["stdout"] <- base::list(NULL)
[17:29:26.592]         }
[17:29:26.592]         base::close(...future.stdout)
[17:29:26.592]         ...future.stdout <- NULL
[17:29:26.592]     }
[17:29:26.592]     ...future.result$conditions <- ...future.conditions
[17:29:26.592]     ...future.result$finished <- base::Sys.time()
[17:29:26.592]     ...future.result
[17:29:26.592] }
[17:29:26.600] Poll #1 (0): usedNodes() = 2, workers = 2
[17:29:26.613] receiveMessageFromWorker() for ClusterFuture ...
[17:29:26.614] - Validating connection of MultisessionFuture
[17:29:26.614] - received message: FutureResult
[17:29:26.615] - Received FutureResult
[17:29:26.615] - Erased future from FutureRegistry
[17:29:26.615] result() for ClusterFuture ...
[17:29:26.616] - result already collected: FutureResult
[17:29:26.616] result() for ClusterFuture ... done
[17:29:26.616] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:26.617] result() for ClusterFuture ...
[17:29:26.617] - result already collected: FutureResult
[17:29:26.617] result() for ClusterFuture ... done
[17:29:26.617] result() for ClusterFuture ...
[17:29:26.618] - result already collected: FutureResult
[17:29:26.618] result() for ClusterFuture ... done
[17:29:26.620] MultisessionFuture started
[17:29:26.620] - Launch lazy future ... done
[17:29:26.621] run() for 'MultisessionFuture' ... done
[17:29:26.622] resolve() on list environment ...
[17:29:26.622]  recursive: 0
[17:29:26.624]  length: 4
[17:29:26.624]  elements: 'a', 'b', 'c', 'd'
[17:29:26.624] Future #1
[17:29:26.624]  length: 3 (resolved future 1)
[17:29:26.816] receiveMessageFromWorker() for ClusterFuture ...
[17:29:26.817] - Validating connection of MultisessionFuture
[17:29:26.817] - received message: FutureResult
[17:29:26.818] - Received FutureResult
[17:29:26.818] - Erased future from FutureRegistry
[17:29:26.818] result() for ClusterFuture ...
[17:29:26.819] - result already collected: FutureResult
[17:29:26.819] result() for ClusterFuture ... done
[17:29:26.819] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:26.819] Future #3
[17:29:26.820]  length: 2 (resolved future 3)
[17:29:26.820]  length: 1 (resolved future 4)
[17:29:27.091] receiveMessageFromWorker() for ClusterFuture ...
[17:29:27.092] - Validating connection of MultisessionFuture
[17:29:27.092] - received message: FutureResult
[17:29:27.093] - Received FutureResult
[17:29:27.093] - Erased future from FutureRegistry
[17:29:27.093] result() for ClusterFuture ...
[17:29:27.094] - result already collected: FutureResult
[17:29:27.094] result() for ClusterFuture ... done
[17:29:27.094] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:27.095] Future #2
[17:29:27.095]  length: 0 (resolved future 2)
[17:29:27.095] resolve() on list environment ... DONE
[17:29:27.096] resolve() on list environment ...
[17:29:27.096]  recursive: 0
[17:29:27.098]  length: 4
[17:29:27.098]  elements: 'a', 'b', 'c', 'd'
[17:29:27.099] Future #1
[17:29:27.099]  length: 3 (resolved future 1)
[17:29:27.099] Future #2
[17:29:27.100]  length: 2 (resolved future 2)
[17:29:27.100] Future #3
[17:29:27.100]  length: 1 (resolved future 3)
[17:29:27.101]  length: 0 (resolved future 4)
[17:29:27.101] resolve() on list environment ... DONE
[17:29:27.102] resolve() on list environment ...
[17:29:27.102]  recursive: 0
[17:29:27.103]  length: 4
[17:29:27.104]  elements: 'a', 'b', 'c', 'd'
[17:29:27.104] Future #1
[17:29:27.104]  length: 3 (resolved future 1)
[17:29:27.105] Future #2
[17:29:27.105]  length: 2 (resolved future 2)
[17:29:27.105] Future #3
[17:29:27.106]  length: 1 (resolved future 3)
[17:29:27.106]  length: 0 (resolved future 4)
[17:29:27.106] resolve() on list environment ... DONE
[17:29:27.108] resolve() on list environment ...
[17:29:27.108]  recursive: 0
[17:29:27.109]  length: 4
[17:29:27.110]  elements: 'a', 'b', 'c', 'd'
[17:29:27.110] Future #1
[17:29:27.110]  length: 3 (resolved future 1)
[17:29:27.111] Future #2
[17:29:27.111]  length: 2 (resolved future 2)
[17:29:27.111] Future #3
[17:29:27.112]  length: 1 (resolved future 3)
[17:29:27.112]  length: 0 (resolved future 4)
[17:29:27.112] resolve() on list environment ... DONE
[17:29:27.114] resolve() on list environment ...
[17:29:27.114]  recursive: 0
[17:29:27.115]  length: 4
[17:29:27.116]  elements: 'a', 'b', 'c', 'd'
[17:29:27.116] Future #1
[17:29:27.116] result() for ClusterFuture ...
[17:29:27.117] - result already collected: FutureResult
[17:29:27.117] result() for ClusterFuture ... done
[17:29:27.117] result() for ClusterFuture ...
[17:29:27.118] - result already collected: FutureResult
[17:29:27.118] result() for ClusterFuture ... done
[17:29:27.118]  length: 3 (resolved future 1)
[17:29:27.119] Future #2
[17:29:27.119] result() for ClusterFuture ...
[17:29:27.119] - result already collected: FutureResult
[17:29:27.120] result() for ClusterFuture ... done
[17:29:27.120] result() for ClusterFuture ...
[17:29:27.120] - result already collected: FutureResult
[17:29:27.120] result() for ClusterFuture ... done
[17:29:27.121]  length: 2 (resolved future 2)
[17:29:27.121] Future #3
[17:29:27.122] result() for ClusterFuture ...
[17:29:27.122] - result already collected: FutureResult
[17:29:27.122] result() for ClusterFuture ... done
[17:29:27.122] result() for ClusterFuture ...
[17:29:27.123] - result already collected: FutureResult
[17:29:27.123] result() for ClusterFuture ... done
[17:29:27.123]  length: 1 (resolved future 3)
[17:29:27.124]  length: 0 (resolved future 4)
[17:29:27.124] resolve() on list environment ... DONE
[17:29:27.125] resolve() on list environment ...
[17:29:27.126]  recursive: 99
[17:29:27.127]  length: 4
[17:29:27.127]  elements: 'a', 'b', 'c', 'd'
[17:29:27.128] Future #1
[17:29:27.128] result() for ClusterFuture ...
[17:29:27.128] - result already collected: FutureResult
[17:29:27.129] result() for ClusterFuture ... done
[17:29:27.129] result() for ClusterFuture ...
[17:29:27.129] - result already collected: FutureResult
[17:29:27.130] result() for ClusterFuture ... done
[17:29:27.130] A MultisessionFuture was resolved
[17:29:27.130]  length: 3 (resolved future 1)
[17:29:27.131] Future #2
[17:29:27.131] result() for ClusterFuture ...
[17:29:27.131] - result already collected: FutureResult
[17:29:27.132] result() for ClusterFuture ... done
[17:29:27.132] result() for ClusterFuture ...
[17:29:27.132] - result already collected: FutureResult
[17:29:27.132] result() for ClusterFuture ... done
[17:29:27.133] A MultisessionFuture was resolved
[17:29:27.133]  length: 2 (resolved future 2)
[17:29:27.134] Future #3
[17:29:27.134] result() for ClusterFuture ...
[17:29:27.134] - result already collected: FutureResult
[17:29:27.134] result() for ClusterFuture ... done
[17:29:27.135] result() for ClusterFuture ...
[17:29:27.135] - result already collected: FutureResult
[17:29:27.135] result() for ClusterFuture ... done
[17:29:27.136] A MultisessionFuture was resolved
[17:29:27.136]  length: 1 (resolved future 3)
[17:29:27.136]  length: 0 (resolved future 4)
[17:29:27.137] resolve() on list environment ... DONE
*** resolve() for list environments ... DONE
- plan('multisession') ...
> 
> 
> message("*** resolve() - globals with non-trustful length() ...")
*** resolve() - globals with non-trustful length() ...
> 
> length.CantTrustLength <- function(x) length(unclass(x)) + 1L
> 
> .length <- future:::.length
> 
> x <- structure(as.list(1:3), class = c("CantTrustLength", "list"))
> str(list(n = length(x), n_true = .length(x)))
List of 2
 $ n     : int 4
 $ n_true: int 3
> stopifnot(length(x) > .length(x))
> x <- resolve(x)
[17:29:27.143] resolve() on list ...
[17:29:27.144]  recursive: 0
[17:29:27.144]  length: 3
[17:29:27.144] 
[17:29:27.145]  length: 2 (resolved future 1)
[17:29:27.145]  length: 1 (resolved future 2)
[17:29:27.145]  length: 0 (resolved future 3)
[17:29:27.146] resolve() on list ... DONE
> 
> message("*** resolve() - globals with non-trustful length() ... DONE")
*** resolve() - globals with non-trustful length() ... DONE
> 
> 
> message("*** resolved() - default ...")
*** resolved() - default ...
> 
> res <- resolved(42L)
> stopifnot(isTRUE(res))
> 
> message("*** resolved() - default ... DONE")
*** resolved() - default ... DONE
> 
> 
> message("*** resolve() ... DONE")
*** resolve() ... DONE
> 
> source("incl/end.R")
[17:29:27.148] plan(): Setting new future strategy stack:
[17:29:27.148] List of future strategies:
[17:29:27.148] 1. FutureStrategy:
[17:29:27.148]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:27.148]    - tweaked: FALSE
[17:29:27.148]    - call: future::plan(oplan)
[17:29:27.158] plan(): nbrOfWorkers() = 1
Failed to undo environment variables:
 - Expected environment variables: [n=205] '!ExitCode', 'ALLUSERSPROFILE', 'APPDATA', 'BIBINPUTS', 'BINDIR', 'BSTINPUTS', 'COMMONPROGRAMFILES', 'COMPUTERNAME', 'COMSPEC', 'CURL_CA_BUNDLE', 'CYGWIN', 'CommonProgramFiles(x86)', 'CommonProgramW6432', 'DriverData', 'HOME', 'HOMEDRIVE', 'HOMEPATH', 'JAGS_ROOT', 'JAVA_HOME', 'LANGUAGE', 'LC_COLLATE', 'LC_MONETARY', 'LC_TIME', 'LOCALAPPDATA', 'LOGONSERVER', 'LS_HOME', 'LS_LICENSE_PATH', 'MAKE', 'MAKEFLAGS', 'MAKELEVEL', 'MFLAGS', 'MSMPI_BENCHMARKS', 'MSMPI_BIN', 'MSYS2_ENV_CONV_EXCL', 'NUMBER_OF_PROCESSORS', 'OCL', 'OMP_THREAD_LIMIT', 'OS', 'PATH', 'PATHEXT', 'PROCESSOR_ARCHITECTURE', 'PROCESSOR_IDENTIFIER', 'PROCESSOR_LEVEL', 'PROCESSOR_REVISION', 'PROGRAMFILES', 'PROMPT', 'PSModulePath', 'PUBLIC', 'PWD', 'ProgramData', 'ProgramFiles(x86)', 'ProgramW6432', 'RTOOLS43_HOME', 'RTOOLS44_HOME', 'R_ARCH', 'R_BROWSER', 'R_BZIPCMD', 'R_CMD', 'R_COMPILED_BY', 'R_CRAN_WEB', 'R_CUSTOM_TOOLS_PATH', 'R_CUSTOM_TOOLS_SOFT', 'R_DOC_DIR', 'R_ENVIRON_USER', 'R_GSCMD', 'R_GZIPCMD', 'R_HOME', 'R_INCLUDE_DIR', 'R_INSTALL_TAR', 'R_LIBS', 'R_LIBS_SITE', 'R_LIBS_USER', 'R_MAX_NUM_DLLS', 'R_OSTYPE', 'R_PAPERSIZE', 'R_PAPERSIZE_USER', 'R_PARALLELLY_MAKENODEPSOCK_AUTOKILL', 'R_PARALLELLY_MAKENODEPSOCK_CONNECTTIMEOUT', 'R_PARALLELLY_MAKENODEPSOCK_RSCRIPT_LABEL', 'R_PARALLELLY_MAKENODEPSOCK_SESSIONINFO_PKGS', 'R_PARALLELLY_MAKENODEPSOCK_TIMEOUT', 'R_PARALLELLY_RANDOM_PORTS', 'R_PARALLEL_PORT', 'R_RD4PDF', 'R_RTOOLS44_PATH', 'R_SCRIPT_LEGACY', 'R_SHARE_DIR', 'R_TESTS', 'R_UNZIPCMD', 'R_USER', 'R_VERSION', 'R_ZIPCMD', 'SED', 'SHLVL', 'SYSTEMDRIVE', 'SYSTEMROOT', 'TAR', 'TAR_OPTIONS', 'TEMP', 'TERM', 'TEXINPUTS', 'TMP', 'TMPDIR', 'USERDOMAIN', 'USERDOMAIN_ROAMINGPROFILE', 'USERNAME', 'USERPROFILE', 'WINDIR', '_', '_R_CHECK_AUTOCONF_', '_R_CHECK_BOGUS_RETURN_', '_R_CHECK_BROWSER_NONINTERACTIVE_', '_R_CHECK_BUILD_VIGNETTES_SEPARATELY_', '_R_CHECK_CODETOOLS_PROFILE_', '_R_CHECK_CODE_ASSIGN_TO_GLOBALENV_', '_R_CHECK_CODE_ATTACH_', '_R_CHECK_CODE_CLASS_IS_STRING_', '_R_CHECK_CODE_DATA_INTO_GLOBALENV_', '_R_CHECK_CODE_USAGE_VIA_NAMESPACES_', '_R_CHECK_CODE_USAGE_WITHOUT_LOADING_', '_R_CHECK_CODE_USAGE_WITH_ONLY_BASE_ATTACHED_', '_R_CHECK_CODOC_VARIABLES_IN_USAGES_', '_R_CHECK_COMPACT_DATA2_', '_R_CHECK_COMPILATION_FLAGS_', '_R_CHECK_CONNECTIONS_LEFT_OPEN_', '_R_CHECK_CRAN_INCOMING_', '_R_CHECK_CRAN_INCOMING_CHECK_FILE_URIS_', '_R_CHECK_CRAN_INCOMING_CHECK_URLS_IN_PARALLEL_', '_R_CHECK_CRAN_INCOMING_NOTE_GNU_MAKE_', '_R_CHECK_CRAN_INCOMING_REMOTE_', '_R_CHECK_CRAN_INCOMING_USE_ASPELL_', '_R_CHECK_DATALIST_', '_R_CHECK_DEPRECATED_DEFUNCT_', '_R_CHECK_DOC_SIZES2_', '_R_CHECK_DOT_FIRSTLIB_', '_R_CHECK_DOT_INTERNAL_', '_R_CHECK_EXAMPLE_TIMING_THRESHOLD_', '_R_CHECK_EXECUTABLES_', '_R_CHECK_EXECUTABLES_EXCLUSIONS_', '_R_CHECK_FF_CALLS_', '_R_CHECK_FF_DUP_', '_R_CHECK_FORCE_SUGGESTS_', '_R_CHECK_FUTURE_FILE_TIMESTAMPS_', '_R_CHECK_FUTURE_FILE_TIMESTAMPS_LEEWAY_', '_R_CHECK_HAVE_MYSQL_', '_R_CHECK_HAVE_ODBC_', '_R_CHECK_HAVE_PERL_', '_R_CHECK_HAVE_POSTGRES_', '_R_CHECK_INSTALL_DEPENDS_', '_R_CHECK_INTERNALS2_', '_R_CHECK_LENGTH_1_CONDITION_', '_R_CHECK_LICENSE_', '_R_CHECK_LIMIT_CORES_', '_R_CHECK_MATRIX_DATA_', '_R_CHECK_MBCS_CONVERSION_FAILURE_', '_R_CHECK_NATIVE_ROUTINE_REGISTRATION_', '_R_CHECK_NEWS_IN_PLAIN_TEXT_', '_R_CHECK_NO_RECOMMENDED_', '_R_CHECK_NO_STOP_ON_TEST_ERROR_', '_R_CHECK_ORPHANED_', '_R_CHECK_OVERWRITE_REGISTERED_S3_METHODS_', '_R_CHECK_PACKAGES_USED_IGNORE_UNUSED_IMPORTS_', '_R_CHECK_PACKAGES_USED_IN_TESTS_USE_SUBDIRS_', '_R_CHECK_PACKAGE_DATASETS_SUPPRESS_NOTES_', '_R_CHECK_PACKAGE_NAME_', '_R_CHECK_PKG_SIZES_', '_R_CHECK_PKG_SIZES_THRESHOLD_', '_R_CHECK_PRAGMAS_', '_R_CHECK_RD_EXAMPLES_T_AND_F_', '_R_CHECK_RD_LINE_WIDTHS_', '_R_CHECK_RD_MATH_RENDERING_', '_R_CHECK_RD_NOTE_LOST_BRACES_', '_R_CHECK_RD_VALIDATE_RD2HTML_', '_R_CHECK_REPLACING_IMPORTS_', '_R_CHECK_R_DEPENDS_', '_R_CHECK_S3_METHODS_SHOW_POSSIBLE_ISSUES_', '_R_CHECK_SCREEN_DEVICE_', '_R_CHECK_SERIALIZATION_', '_R_CHECK_SHLIB_OPENMP_FLAGS_', '_R_CHECK_SRC_MINUS_W_IMPLICIT_', '_R_CHECK_SUBDIRS_NOCASE_', '_R_CHECK_SUGGESTS_ONLY_', '_R_CHECK_SYSTEM_CLOCK_', '_R_CHECK_TESTS_NLINES_', '_R_CHECK_TEST_TIMING_', '_R_CHECK_TIMINGS_', '_R_CHECK_TOPLEVEL_FILES_', '_R_CHECK_UNDOC_USE_ALL_NAMES_', '_R_CHECK_UNSAFE_CALLS_', '_R_CHECK_URLS_SHOW_301_STATUS_', '_R_CHECK_VC_DIRS_', '_R_CHECK_VIGNETTES_NLINES_', '_R_CHECK_VIGNETTES_SKIP_RUN_MAYBE_', '_R_CHECK_VIGNETTE_TIMING_', '_R_CHECK_VIGNETTE_TITLES_', '_R_CHECK_WINDOWS_DEVICE_', '_R_CHECK_XREFS_NOTE_MISSING_PACKAGE_ANCHORS_', '_R_CHECK_XREFS_USE_ALIASES_FROM_CRAN_', '_R_CLASS_MATRIX_ARRAY_', '_R_DEPRECATED_IS_R_', '_R_S3_METHOD_LOOKUP_BASEENV_AFTER_GLOBALENV_', '_R_SHLIB_BUILD_OBJECTS_SYMBOL_TABLES_', '__R_CHECK_DOC_FILES_NOTE_IF_ALL_SPECIAL__', 'maj.version', 'nextArg--timingsnextArg--install'
 - Environment variables still there: [n=0] 
 - Environment variables missing: [n=1] 'MAKEFLAGS'
Differences environment variable by environment variable:
List of 3
 $ name    : chr "MAKEFLAGS"
 $ expected: 'Dlist' chr ""
 $ actual  : 'Dlist' chr NA
> 
> proc.time()
   user  system elapsed 
   5.85    0.26   24.51