R Under development (unstable) (2023-12-20 r85713 ucrt) -- "Unsuffered Consequences"
Copyright (C) 2023 The R Foundation for Statistical Computing
Platform: x86_64-w64-mingw32/x64

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

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

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

> source("incl/start.R")
[01:28:52.444] plan(): Setting new future strategy stack:
[01:28:52.446] List of future strategies:
[01:28:52.446] 1. sequential:
[01:28:52.446]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:52.446]    - tweaked: FALSE
[01:28:52.446]    - call: future::plan("sequential")
[01:28:52.462] 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') ...
[01:28:52.765] plan(): Setting new future strategy stack:
[01:28:52.765] List of future strategies:
[01:28:52.765] 1. sequential:
[01:28:52.765]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:52.765]    - tweaked: FALSE
[01:28:52.765]    - call: plan(strategy)
[01:28:52.787] plan(): nbrOfWorkers() = 1
*** resolve() for lists ...
[01:28:52.788] resolve() on list ...
[01:28:52.788]  recursive: 0
[01:28:52.789]  length: 2
[01:28:52.789]  elements: 'a', 'b'
[01:28:52.789]  length: 1 (resolved future 1)
[01:28:52.789]  length: 0 (resolved future 2)
[01:28:52.790] resolve() on list ... DONE
[01:28:52.791] getGlobalsAndPackages() ...
[01:28:52.791] Searching for globals...
[01:28:52.794] 
[01:28:52.795] Searching for globals ... DONE
[01:28:52.795] - globals: [0] <none>
[01:28:52.795] getGlobalsAndPackages() ... DONE
[01:28:52.797] run() for 'Future' ...
[01:28:52.797] - state: 'created'
[01:28:52.798] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:52.798] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:52.799] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:52.799]   - Field: 'label'
[01:28:52.799]   - Field: 'local'
[01:28:52.799]   - Field: 'owner'
[01:28:52.799]   - Field: 'envir'
[01:28:52.800]   - Field: 'packages'
[01:28:52.800]   - Field: 'gc'
[01:28:52.800]   - Field: 'conditions'
[01:28:52.800]   - Field: 'expr'
[01:28:52.801]   - Field: 'uuid'
[01:28:52.804]   - Field: 'seed'
[01:28:52.804]   - Field: 'version'
[01:28:52.805]   - Field: 'result'
[01:28:52.805]   - Field: 'asynchronous'
[01:28:52.805]   - Field: 'calls'
[01:28:52.805]   - Field: 'globals'
[01:28:52.806]   - Field: 'stdout'
[01:28:52.806]   - Field: 'earlySignal'
[01:28:52.806]   - Field: 'lazy'
[01:28:52.807]   - Field: 'state'
[01:28:52.807] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:52.807] - Launch lazy future ...
[01:28:52.809] Packages needed by the future expression (n = 0): <none>
[01:28:52.809] Packages needed by future strategies (n = 0): <none>
[01:28:52.811] {
[01:28:52.811]     {
[01:28:52.811]         {
[01:28:52.811]             ...future.startTime <- base::Sys.time()
[01:28:52.811]             {
[01:28:52.811]                 {
[01:28:52.811]                   {
[01:28:52.811]                     base::local({
[01:28:52.811]                       has_future <- base::requireNamespace("future", 
[01:28:52.811]                         quietly = TRUE)
[01:28:52.811]                       if (has_future) {
[01:28:52.811]                         ns <- base::getNamespace("future")
[01:28:52.811]                         version <- ns[[".package"]][["version"]]
[01:28:52.811]                         if (is.null(version)) 
[01:28:52.811]                           version <- utils::packageVersion("future")
[01:28:52.811]                       }
[01:28:52.811]                       else {
[01:28:52.811]                         version <- NULL
[01:28:52.811]                       }
[01:28:52.811]                       if (!has_future || version < "1.8.0") {
[01:28:52.811]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:52.811]                           "", base::R.version$version.string), 
[01:28:52.811]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:52.811]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:52.811]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:52.811]                             "release", "version")], collapse = " "), 
[01:28:52.811]                           hostname = base::Sys.info()[["nodename"]])
[01:28:52.811]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:52.811]                           info)
[01:28:52.811]                         info <- base::paste(info, collapse = "; ")
[01:28:52.811]                         if (!has_future) {
[01:28:52.811]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:52.811]                             info)
[01:28:52.811]                         }
[01:28:52.811]                         else {
[01:28:52.811]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:52.811]                             info, version)
[01:28:52.811]                         }
[01:28:52.811]                         base::stop(msg)
[01:28:52.811]                       }
[01:28:52.811]                     })
[01:28:52.811]                   }
[01:28:52.811]                   options(future.plan = NULL)
[01:28:52.811]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:52.811]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:52.811]                 }
[01:28:52.811]                 ...future.workdir <- getwd()
[01:28:52.811]             }
[01:28:52.811]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:52.811]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:52.811]         }
[01:28:52.811]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:52.811]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:52.811]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:52.811]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:52.811]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:52.811]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:52.811]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:52.811]             base::names(...future.oldOptions))
[01:28:52.811]     }
[01:28:52.811]     if (FALSE) {
[01:28:52.811]     }
[01:28:52.811]     else {
[01:28:52.811]         if (TRUE) {
[01:28:52.811]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:52.811]                 open = "w")
[01:28:52.811]         }
[01:28:52.811]         else {
[01:28:52.811]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:52.811]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:52.811]         }
[01:28:52.811]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:52.811]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:52.811]             base::sink(type = "output", split = FALSE)
[01:28:52.811]             base::close(...future.stdout)
[01:28:52.811]         }, add = TRUE)
[01:28:52.811]     }
[01:28:52.811]     ...future.frame <- base::sys.nframe()
[01:28:52.811]     ...future.conditions <- base::list()
[01:28:52.811]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:52.811]     if (FALSE) {
[01:28:52.811]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:52.811]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:52.811]     }
[01:28:52.811]     ...future.result <- base::tryCatch({
[01:28:52.811]         base::withCallingHandlers({
[01:28:52.811]             ...future.value <- base::withVisible(base::local(1))
[01:28:52.811]             future::FutureResult(value = ...future.value$value, 
[01:28:52.811]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:52.811]                   ...future.rng), globalenv = if (FALSE) 
[01:28:52.811]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:52.811]                     ...future.globalenv.names))
[01:28:52.811]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:52.811]         }, condition = base::local({
[01:28:52.811]             c <- base::c
[01:28:52.811]             inherits <- base::inherits
[01:28:52.811]             invokeRestart <- base::invokeRestart
[01:28:52.811]             length <- base::length
[01:28:52.811]             list <- base::list
[01:28:52.811]             seq.int <- base::seq.int
[01:28:52.811]             signalCondition <- base::signalCondition
[01:28:52.811]             sys.calls <- base::sys.calls
[01:28:52.811]             `[[` <- base::`[[`
[01:28:52.811]             `+` <- base::`+`
[01:28:52.811]             `<<-` <- base::`<<-`
[01:28:52.811]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:52.811]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:52.811]                   3L)]
[01:28:52.811]             }
[01:28:52.811]             function(cond) {
[01:28:52.811]                 is_error <- inherits(cond, "error")
[01:28:52.811]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:52.811]                   NULL)
[01:28:52.811]                 if (is_error) {
[01:28:52.811]                   sessionInformation <- function() {
[01:28:52.811]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:52.811]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:52.811]                       search = base::search(), system = base::Sys.info())
[01:28:52.811]                   }
[01:28:52.811]                   ...future.conditions[[length(...future.conditions) + 
[01:28:52.811]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:52.811]                     cond$call), session = sessionInformation(), 
[01:28:52.811]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:52.811]                   signalCondition(cond)
[01:28:52.811]                 }
[01:28:52.811]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:52.811]                 "immediateCondition"))) {
[01:28:52.811]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:52.811]                   ...future.conditions[[length(...future.conditions) + 
[01:28:52.811]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:52.811]                   if (TRUE && !signal) {
[01:28:52.811]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:52.811]                     {
[01:28:52.811]                       inherits <- base::inherits
[01:28:52.811]                       invokeRestart <- base::invokeRestart
[01:28:52.811]                       is.null <- base::is.null
[01:28:52.811]                       muffled <- FALSE
[01:28:52.811]                       if (inherits(cond, "message")) {
[01:28:52.811]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:52.811]                         if (muffled) 
[01:28:52.811]                           invokeRestart("muffleMessage")
[01:28:52.811]                       }
[01:28:52.811]                       else if (inherits(cond, "warning")) {
[01:28:52.811]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:52.811]                         if (muffled) 
[01:28:52.811]                           invokeRestart("muffleWarning")
[01:28:52.811]                       }
[01:28:52.811]                       else if (inherits(cond, "condition")) {
[01:28:52.811]                         if (!is.null(pattern)) {
[01:28:52.811]                           computeRestarts <- base::computeRestarts
[01:28:52.811]                           grepl <- base::grepl
[01:28:52.811]                           restarts <- computeRestarts(cond)
[01:28:52.811]                           for (restart in restarts) {
[01:28:52.811]                             name <- restart$name
[01:28:52.811]                             if (is.null(name)) 
[01:28:52.811]                               next
[01:28:52.811]                             if (!grepl(pattern, name)) 
[01:28:52.811]                               next
[01:28:52.811]                             invokeRestart(restart)
[01:28:52.811]                             muffled <- TRUE
[01:28:52.811]                             break
[01:28:52.811]                           }
[01:28:52.811]                         }
[01:28:52.811]                       }
[01:28:52.811]                       invisible(muffled)
[01:28:52.811]                     }
[01:28:52.811]                     muffleCondition(cond, pattern = "^muffle")
[01:28:52.811]                   }
[01:28:52.811]                 }
[01:28:52.811]                 else {
[01:28:52.811]                   if (TRUE) {
[01:28:52.811]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:52.811]                     {
[01:28:52.811]                       inherits <- base::inherits
[01:28:52.811]                       invokeRestart <- base::invokeRestart
[01:28:52.811]                       is.null <- base::is.null
[01:28:52.811]                       muffled <- FALSE
[01:28:52.811]                       if (inherits(cond, "message")) {
[01:28:52.811]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:52.811]                         if (muffled) 
[01:28:52.811]                           invokeRestart("muffleMessage")
[01:28:52.811]                       }
[01:28:52.811]                       else if (inherits(cond, "warning")) {
[01:28:52.811]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:52.811]                         if (muffled) 
[01:28:52.811]                           invokeRestart("muffleWarning")
[01:28:52.811]                       }
[01:28:52.811]                       else if (inherits(cond, "condition")) {
[01:28:52.811]                         if (!is.null(pattern)) {
[01:28:52.811]                           computeRestarts <- base::computeRestarts
[01:28:52.811]                           grepl <- base::grepl
[01:28:52.811]                           restarts <- computeRestarts(cond)
[01:28:52.811]                           for (restart in restarts) {
[01:28:52.811]                             name <- restart$name
[01:28:52.811]                             if (is.null(name)) 
[01:28:52.811]                               next
[01:28:52.811]                             if (!grepl(pattern, name)) 
[01:28:52.811]                               next
[01:28:52.811]                             invokeRestart(restart)
[01:28:52.811]                             muffled <- TRUE
[01:28:52.811]                             break
[01:28:52.811]                           }
[01:28:52.811]                         }
[01:28:52.811]                       }
[01:28:52.811]                       invisible(muffled)
[01:28:52.811]                     }
[01:28:52.811]                     muffleCondition(cond, pattern = "^muffle")
[01:28:52.811]                   }
[01:28:52.811]                 }
[01:28:52.811]             }
[01:28:52.811]         }))
[01:28:52.811]     }, error = function(ex) {
[01:28:52.811]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:52.811]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:52.811]                 ...future.rng), started = ...future.startTime, 
[01:28:52.811]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:52.811]             version = "1.8"), class = "FutureResult")
[01:28:52.811]     }, finally = {
[01:28:52.811]         if (!identical(...future.workdir, getwd())) 
[01:28:52.811]             setwd(...future.workdir)
[01:28:52.811]         {
[01:28:52.811]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:52.811]                 ...future.oldOptions$nwarnings <- NULL
[01:28:52.811]             }
[01:28:52.811]             base::options(...future.oldOptions)
[01:28:52.811]             if (.Platform$OS.type == "windows") {
[01:28:52.811]                 old_names <- names(...future.oldEnvVars)
[01:28:52.811]                 envs <- base::Sys.getenv()
[01:28:52.811]                 names <- names(envs)
[01:28:52.811]                 common <- intersect(names, old_names)
[01:28:52.811]                 added <- setdiff(names, old_names)
[01:28:52.811]                 removed <- setdiff(old_names, names)
[01:28:52.811]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:52.811]                   envs[common]]
[01:28:52.811]                 NAMES <- toupper(changed)
[01:28:52.811]                 args <- list()
[01:28:52.811]                 for (kk in seq_along(NAMES)) {
[01:28:52.811]                   name <- changed[[kk]]
[01:28:52.811]                   NAME <- NAMES[[kk]]
[01:28:52.811]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:52.811]                     next
[01:28:52.811]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:52.811]                 }
[01:28:52.811]                 NAMES <- toupper(added)
[01:28:52.811]                 for (kk in seq_along(NAMES)) {
[01:28:52.811]                   name <- added[[kk]]
[01:28:52.811]                   NAME <- NAMES[[kk]]
[01:28:52.811]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:52.811]                     next
[01:28:52.811]                   args[[name]] <- ""
[01:28:52.811]                 }
[01:28:52.811]                 NAMES <- toupper(removed)
[01:28:52.811]                 for (kk in seq_along(NAMES)) {
[01:28:52.811]                   name <- removed[[kk]]
[01:28:52.811]                   NAME <- NAMES[[kk]]
[01:28:52.811]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:52.811]                     next
[01:28:52.811]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:52.811]                 }
[01:28:52.811]                 if (length(args) > 0) 
[01:28:52.811]                   base::do.call(base::Sys.setenv, args = args)
[01:28:52.811]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:52.811]             }
[01:28:52.811]             else {
[01:28:52.811]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:52.811]             }
[01:28:52.811]             {
[01:28:52.811]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:52.811]                   0L) {
[01:28:52.811]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:52.811]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:52.811]                   base::options(opts)
[01:28:52.811]                 }
[01:28:52.811]                 {
[01:28:52.811]                   {
[01:28:52.811]                     NULL
[01:28:52.811]                     RNGkind("Mersenne-Twister")
[01:28:52.811]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:52.811]                       inherits = FALSE)
[01:28:52.811]                   }
[01:28:52.811]                   options(future.plan = NULL)
[01:28:52.811]                   if (is.na(NA_character_)) 
[01:28:52.811]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:52.811]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:52.811]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:52.811]                   {
[01:28:52.811]                     future <- SequentialFuture(..., envir = envir)
[01:28:52.811]                     if (!future$lazy) 
[01:28:52.811]                       future <- run(future)
[01:28:52.811]                     invisible(future)
[01:28:52.811]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:52.811]                 }
[01:28:52.811]             }
[01:28:52.811]         }
[01:28:52.811]     })
[01:28:52.811]     if (TRUE) {
[01:28:52.811]         base::sink(type = "output", split = FALSE)
[01:28:52.811]         if (TRUE) {
[01:28:52.811]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:52.811]         }
[01:28:52.811]         else {
[01:28:52.811]             ...future.result["stdout"] <- base::list(NULL)
[01:28:52.811]         }
[01:28:52.811]         base::close(...future.stdout)
[01:28:52.811]         ...future.stdout <- NULL
[01:28:52.811]     }
[01:28:52.811]     ...future.result$conditions <- ...future.conditions
[01:28:52.811]     ...future.result$finished <- base::Sys.time()
[01:28:52.811]     ...future.result
[01:28:52.811] }
[01:28:52.817] plan(): Setting new future strategy stack:
[01:28:52.817] List of future strategies:
[01:28:52.817] 1. sequential:
[01:28:52.817]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:52.817]    - tweaked: FALSE
[01:28:52.817]    - call: NULL
[01:28:52.818] plan(): nbrOfWorkers() = 1
[01:28:52.821] plan(): Setting new future strategy stack:
[01:28:52.822] List of future strategies:
[01:28:52.822] 1. sequential:
[01:28:52.822]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:52.822]    - tweaked: FALSE
[01:28:52.822]    - call: plan(strategy)
[01:28:52.822] plan(): nbrOfWorkers() = 1
[01:28:52.823] SequentialFuture started (and completed)
[01:28:52.824] - Launch lazy future ... done
[01:28:52.824] run() for 'SequentialFuture' ... done
[01:28:52.825] getGlobalsAndPackages() ...
[01:28:52.825] Searching for globals...
[01:28:52.826] 
[01:28:52.826] Searching for globals ... DONE
[01:28:52.826] - globals: [0] <none>
[01:28:52.826] getGlobalsAndPackages() ... DONE
[01:28:52.827] run() for 'Future' ...
[01:28:52.827] - state: 'created'
[01:28:52.828] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:52.828] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:52.829] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:52.829]   - Field: 'label'
[01:28:52.829]   - Field: 'local'
[01:28:52.829]   - Field: 'owner'
[01:28:52.830]   - Field: 'envir'
[01:28:52.830]   - Field: 'packages'
[01:28:52.830]   - Field: 'gc'
[01:28:52.831]   - Field: 'conditions'
[01:28:52.831]   - Field: 'expr'
[01:28:52.831]   - Field: 'uuid'
[01:28:52.832]   - Field: 'seed'
[01:28:52.832]   - Field: 'version'
[01:28:52.832]   - Field: 'result'
[01:28:52.832]   - Field: 'asynchronous'
[01:28:52.833]   - Field: 'calls'
[01:28:52.833]   - Field: 'globals'
[01:28:52.833]   - Field: 'stdout'
[01:28:52.834]   - Field: 'earlySignal'
[01:28:52.834]   - Field: 'lazy'
[01:28:52.834]   - Field: 'state'
[01:28:52.834] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:52.835] - Launch lazy future ...
[01:28:52.835] Packages needed by the future expression (n = 0): <none>
[01:28:52.836] Packages needed by future strategies (n = 0): <none>
[01:28:52.837] {
[01:28:52.837]     {
[01:28:52.837]         {
[01:28:52.837]             ...future.startTime <- base::Sys.time()
[01:28:52.837]             {
[01:28:52.837]                 {
[01:28:52.837]                   {
[01:28:52.837]                     base::local({
[01:28:52.837]                       has_future <- base::requireNamespace("future", 
[01:28:52.837]                         quietly = TRUE)
[01:28:52.837]                       if (has_future) {
[01:28:52.837]                         ns <- base::getNamespace("future")
[01:28:52.837]                         version <- ns[[".package"]][["version"]]
[01:28:52.837]                         if (is.null(version)) 
[01:28:52.837]                           version <- utils::packageVersion("future")
[01:28:52.837]                       }
[01:28:52.837]                       else {
[01:28:52.837]                         version <- NULL
[01:28:52.837]                       }
[01:28:52.837]                       if (!has_future || version < "1.8.0") {
[01:28:52.837]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:52.837]                           "", base::R.version$version.string), 
[01:28:52.837]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:52.837]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:52.837]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:52.837]                             "release", "version")], collapse = " "), 
[01:28:52.837]                           hostname = base::Sys.info()[["nodename"]])
[01:28:52.837]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:52.837]                           info)
[01:28:52.837]                         info <- base::paste(info, collapse = "; ")
[01:28:52.837]                         if (!has_future) {
[01:28:52.837]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:52.837]                             info)
[01:28:52.837]                         }
[01:28:52.837]                         else {
[01:28:52.837]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:52.837]                             info, version)
[01:28:52.837]                         }
[01:28:52.837]                         base::stop(msg)
[01:28:52.837]                       }
[01:28:52.837]                     })
[01:28:52.837]                   }
[01:28:52.837]                   options(future.plan = NULL)
[01:28:52.837]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:52.837]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:52.837]                 }
[01:28:52.837]                 ...future.workdir <- getwd()
[01:28:52.837]             }
[01:28:52.837]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:52.837]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:52.837]         }
[01:28:52.837]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:52.837]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:52.837]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:52.837]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:52.837]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:52.837]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:52.837]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:52.837]             base::names(...future.oldOptions))
[01:28:52.837]     }
[01:28:52.837]     if (FALSE) {
[01:28:52.837]     }
[01:28:52.837]     else {
[01:28:52.837]         if (TRUE) {
[01:28:52.837]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:52.837]                 open = "w")
[01:28:52.837]         }
[01:28:52.837]         else {
[01:28:52.837]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:52.837]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:52.837]         }
[01:28:52.837]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:52.837]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:52.837]             base::sink(type = "output", split = FALSE)
[01:28:52.837]             base::close(...future.stdout)
[01:28:52.837]         }, add = TRUE)
[01:28:52.837]     }
[01:28:52.837]     ...future.frame <- base::sys.nframe()
[01:28:52.837]     ...future.conditions <- base::list()
[01:28:52.837]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:52.837]     if (FALSE) {
[01:28:52.837]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:52.837]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:52.837]     }
[01:28:52.837]     ...future.result <- base::tryCatch({
[01:28:52.837]         base::withCallingHandlers({
[01:28:52.837]             ...future.value <- base::withVisible(base::local(2))
[01:28:52.837]             future::FutureResult(value = ...future.value$value, 
[01:28:52.837]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:52.837]                   ...future.rng), globalenv = if (FALSE) 
[01:28:52.837]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:52.837]                     ...future.globalenv.names))
[01:28:52.837]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:52.837]         }, condition = base::local({
[01:28:52.837]             c <- base::c
[01:28:52.837]             inherits <- base::inherits
[01:28:52.837]             invokeRestart <- base::invokeRestart
[01:28:52.837]             length <- base::length
[01:28:52.837]             list <- base::list
[01:28:52.837]             seq.int <- base::seq.int
[01:28:52.837]             signalCondition <- base::signalCondition
[01:28:52.837]             sys.calls <- base::sys.calls
[01:28:52.837]             `[[` <- base::`[[`
[01:28:52.837]             `+` <- base::`+`
[01:28:52.837]             `<<-` <- base::`<<-`
[01:28:52.837]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:52.837]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:52.837]                   3L)]
[01:28:52.837]             }
[01:28:52.837]             function(cond) {
[01:28:52.837]                 is_error <- inherits(cond, "error")
[01:28:52.837]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:52.837]                   NULL)
[01:28:52.837]                 if (is_error) {
[01:28:52.837]                   sessionInformation <- function() {
[01:28:52.837]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:52.837]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:52.837]                       search = base::search(), system = base::Sys.info())
[01:28:52.837]                   }
[01:28:52.837]                   ...future.conditions[[length(...future.conditions) + 
[01:28:52.837]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:52.837]                     cond$call), session = sessionInformation(), 
[01:28:52.837]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:52.837]                   signalCondition(cond)
[01:28:52.837]                 }
[01:28:52.837]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:52.837]                 "immediateCondition"))) {
[01:28:52.837]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:52.837]                   ...future.conditions[[length(...future.conditions) + 
[01:28:52.837]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:52.837]                   if (TRUE && !signal) {
[01:28:52.837]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:52.837]                     {
[01:28:52.837]                       inherits <- base::inherits
[01:28:52.837]                       invokeRestart <- base::invokeRestart
[01:28:52.837]                       is.null <- base::is.null
[01:28:52.837]                       muffled <- FALSE
[01:28:52.837]                       if (inherits(cond, "message")) {
[01:28:52.837]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:52.837]                         if (muffled) 
[01:28:52.837]                           invokeRestart("muffleMessage")
[01:28:52.837]                       }
[01:28:52.837]                       else if (inherits(cond, "warning")) {
[01:28:52.837]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:52.837]                         if (muffled) 
[01:28:52.837]                           invokeRestart("muffleWarning")
[01:28:52.837]                       }
[01:28:52.837]                       else if (inherits(cond, "condition")) {
[01:28:52.837]                         if (!is.null(pattern)) {
[01:28:52.837]                           computeRestarts <- base::computeRestarts
[01:28:52.837]                           grepl <- base::grepl
[01:28:52.837]                           restarts <- computeRestarts(cond)
[01:28:52.837]                           for (restart in restarts) {
[01:28:52.837]                             name <- restart$name
[01:28:52.837]                             if (is.null(name)) 
[01:28:52.837]                               next
[01:28:52.837]                             if (!grepl(pattern, name)) 
[01:28:52.837]                               next
[01:28:52.837]                             invokeRestart(restart)
[01:28:52.837]                             muffled <- TRUE
[01:28:52.837]                             break
[01:28:52.837]                           }
[01:28:52.837]                         }
[01:28:52.837]                       }
[01:28:52.837]                       invisible(muffled)
[01:28:52.837]                     }
[01:28:52.837]                     muffleCondition(cond, pattern = "^muffle")
[01:28:52.837]                   }
[01:28:52.837]                 }
[01:28:52.837]                 else {
[01:28:52.837]                   if (TRUE) {
[01:28:52.837]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:52.837]                     {
[01:28:52.837]                       inherits <- base::inherits
[01:28:52.837]                       invokeRestart <- base::invokeRestart
[01:28:52.837]                       is.null <- base::is.null
[01:28:52.837]                       muffled <- FALSE
[01:28:52.837]                       if (inherits(cond, "message")) {
[01:28:52.837]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:52.837]                         if (muffled) 
[01:28:52.837]                           invokeRestart("muffleMessage")
[01:28:52.837]                       }
[01:28:52.837]                       else if (inherits(cond, "warning")) {
[01:28:52.837]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:52.837]                         if (muffled) 
[01:28:52.837]                           invokeRestart("muffleWarning")
[01:28:52.837]                       }
[01:28:52.837]                       else if (inherits(cond, "condition")) {
[01:28:52.837]                         if (!is.null(pattern)) {
[01:28:52.837]                           computeRestarts <- base::computeRestarts
[01:28:52.837]                           grepl <- base::grepl
[01:28:52.837]                           restarts <- computeRestarts(cond)
[01:28:52.837]                           for (restart in restarts) {
[01:28:52.837]                             name <- restart$name
[01:28:52.837]                             if (is.null(name)) 
[01:28:52.837]                               next
[01:28:52.837]                             if (!grepl(pattern, name)) 
[01:28:52.837]                               next
[01:28:52.837]                             invokeRestart(restart)
[01:28:52.837]                             muffled <- TRUE
[01:28:52.837]                             break
[01:28:52.837]                           }
[01:28:52.837]                         }
[01:28:52.837]                       }
[01:28:52.837]                       invisible(muffled)
[01:28:52.837]                     }
[01:28:52.837]                     muffleCondition(cond, pattern = "^muffle")
[01:28:52.837]                   }
[01:28:52.837]                 }
[01:28:52.837]             }
[01:28:52.837]         }))
[01:28:52.837]     }, error = function(ex) {
[01:28:52.837]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:52.837]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:52.837]                 ...future.rng), started = ...future.startTime, 
[01:28:52.837]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:52.837]             version = "1.8"), class = "FutureResult")
[01:28:52.837]     }, finally = {
[01:28:52.837]         if (!identical(...future.workdir, getwd())) 
[01:28:52.837]             setwd(...future.workdir)
[01:28:52.837]         {
[01:28:52.837]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:52.837]                 ...future.oldOptions$nwarnings <- NULL
[01:28:52.837]             }
[01:28:52.837]             base::options(...future.oldOptions)
[01:28:52.837]             if (.Platform$OS.type == "windows") {
[01:28:52.837]                 old_names <- names(...future.oldEnvVars)
[01:28:52.837]                 envs <- base::Sys.getenv()
[01:28:52.837]                 names <- names(envs)
[01:28:52.837]                 common <- intersect(names, old_names)
[01:28:52.837]                 added <- setdiff(names, old_names)
[01:28:52.837]                 removed <- setdiff(old_names, names)
[01:28:52.837]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:52.837]                   envs[common]]
[01:28:52.837]                 NAMES <- toupper(changed)
[01:28:52.837]                 args <- list()
[01:28:52.837]                 for (kk in seq_along(NAMES)) {
[01:28:52.837]                   name <- changed[[kk]]
[01:28:52.837]                   NAME <- NAMES[[kk]]
[01:28:52.837]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:52.837]                     next
[01:28:52.837]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:52.837]                 }
[01:28:52.837]                 NAMES <- toupper(added)
[01:28:52.837]                 for (kk in seq_along(NAMES)) {
[01:28:52.837]                   name <- added[[kk]]
[01:28:52.837]                   NAME <- NAMES[[kk]]
[01:28:52.837]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:52.837]                     next
[01:28:52.837]                   args[[name]] <- ""
[01:28:52.837]                 }
[01:28:52.837]                 NAMES <- toupper(removed)
[01:28:52.837]                 for (kk in seq_along(NAMES)) {
[01:28:52.837]                   name <- removed[[kk]]
[01:28:52.837]                   NAME <- NAMES[[kk]]
[01:28:52.837]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:52.837]                     next
[01:28:52.837]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:52.837]                 }
[01:28:52.837]                 if (length(args) > 0) 
[01:28:52.837]                   base::do.call(base::Sys.setenv, args = args)
[01:28:52.837]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:52.837]             }
[01:28:52.837]             else {
[01:28:52.837]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:52.837]             }
[01:28:52.837]             {
[01:28:52.837]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:52.837]                   0L) {
[01:28:52.837]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:52.837]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:52.837]                   base::options(opts)
[01:28:52.837]                 }
[01:28:52.837]                 {
[01:28:52.837]                   {
[01:28:52.837]                     NULL
[01:28:52.837]                     RNGkind("Mersenne-Twister")
[01:28:52.837]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:52.837]                       inherits = FALSE)
[01:28:52.837]                   }
[01:28:52.837]                   options(future.plan = NULL)
[01:28:52.837]                   if (is.na(NA_character_)) 
[01:28:52.837]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:52.837]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:52.837]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:52.837]                   {
[01:28:52.837]                     future <- SequentialFuture(..., envir = envir)
[01:28:52.837]                     if (!future$lazy) 
[01:28:52.837]                       future <- run(future)
[01:28:52.837]                     invisible(future)
[01:28:52.837]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:52.837]                 }
[01:28:52.837]             }
[01:28:52.837]         }
[01:28:52.837]     })
[01:28:52.837]     if (TRUE) {
[01:28:52.837]         base::sink(type = "output", split = FALSE)
[01:28:52.837]         if (TRUE) {
[01:28:52.837]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:52.837]         }
[01:28:52.837]         else {
[01:28:52.837]             ...future.result["stdout"] <- base::list(NULL)
[01:28:52.837]         }
[01:28:52.837]         base::close(...future.stdout)
[01:28:52.837]         ...future.stdout <- NULL
[01:28:52.837]     }
[01:28:52.837]     ...future.result$conditions <- ...future.conditions
[01:28:52.837]     ...future.result$finished <- base::Sys.time()
[01:28:52.837]     ...future.result
[01:28:52.837] }
[01:28:52.842] plan(): Setting new future strategy stack:
[01:28:52.842] List of future strategies:
[01:28:52.842] 1. sequential:
[01:28:52.842]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:52.842]    - tweaked: FALSE
[01:28:52.842]    - call: NULL
[01:28:52.843] plan(): nbrOfWorkers() = 1
[01:28:52.845] plan(): Setting new future strategy stack:
[01:28:52.845] List of future strategies:
[01:28:52.845] 1. sequential:
[01:28:52.845]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:52.845]    - tweaked: FALSE
[01:28:52.845]    - call: plan(strategy)
[01:28:52.846] plan(): nbrOfWorkers() = 1
[01:28:52.847] SequentialFuture started (and completed)
[01:28:52.847] - Launch lazy future ... done
[01:28:52.847] run() for 'SequentialFuture' ... done
[01:28:52.847] resolve() on list ...
[01:28:52.848]  recursive: 0
[01:28:52.848]  length: 3
[01:28:52.848]  elements: 'a', 'b', ''
[01:28:52.849] resolved() for 'SequentialFuture' ...
[01:28:52.849] - state: 'finished'
[01:28:52.849] - run: TRUE
[01:28:52.850] - result: 'FutureResult'
[01:28:52.850] resolved() for 'SequentialFuture' ... done
[01:28:52.850] Future #1
[01:28:52.851]  length: 2 (resolved future 1)
[01:28:52.851] resolved() for 'SequentialFuture' ...
[01:28:52.851] - state: 'finished'
[01:28:52.852] - run: TRUE
[01:28:52.852] - result: 'FutureResult'
[01:28:52.852] resolved() for 'SequentialFuture' ... done
[01:28:52.852] Future #2
[01:28:52.853]  length: 1 (resolved future 2)
[01:28:52.853]  length: 0 (resolved future 3)
[01:28:52.853] resolve() on list ... DONE
[01:28:52.854] resolved() for 'SequentialFuture' ...
[01:28:52.854] - state: 'finished'
[01:28:52.854] - run: TRUE
[01:28:52.854] - result: 'FutureResult'
[01:28:52.855] resolved() for 'SequentialFuture' ... done
[01:28:52.855] resolved() for 'SequentialFuture' ...
[01:28:52.855] - state: 'finished'
[01:28:52.856] - run: TRUE
[01:28:52.856] - result: 'FutureResult'
[01:28:52.856] resolved() for 'SequentialFuture' ... done
[01:28:52.856] getGlobalsAndPackages() ...
[01:28:52.857] Searching for globals...
[01:28:52.858] 
[01:28:52.858] Searching for globals ... DONE
[01:28:52.858] - globals: [0] <none>
[01:28:52.858] getGlobalsAndPackages() ... DONE
[01:28:52.859] getGlobalsAndPackages() ...
[01:28:52.859] Searching for globals...
[01:28:52.860] 
[01:28:52.860] Searching for globals ... DONE
[01:28:52.860] - globals: [0] <none>
[01:28:52.861] getGlobalsAndPackages() ... DONE
[01:28:52.861] run() for 'Future' ...
[01:28:52.861] - state: 'created'
[01:28:52.862] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:52.862] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:52.863] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:52.863]   - Field: 'label'
[01:28:52.863]   - Field: 'local'
[01:28:52.864]   - Field: 'owner'
[01:28:52.864]   - Field: 'envir'
[01:28:52.864]   - Field: 'packages'
[01:28:52.864]   - Field: 'gc'
[01:28:52.865]   - Field: 'conditions'
[01:28:52.865]   - Field: 'expr'
[01:28:52.865]   - Field: 'uuid'
[01:28:52.865]   - Field: 'seed'
[01:28:52.866]   - Field: 'version'
[01:28:52.866]   - Field: 'result'
[01:28:52.866]   - Field: 'asynchronous'
[01:28:52.867]   - Field: 'calls'
[01:28:52.867]   - Field: 'globals'
[01:28:52.867]   - Field: 'stdout'
[01:28:52.868]   - Field: 'earlySignal'
[01:28:52.868]   - Field: 'lazy'
[01:28:52.868]   - Field: 'state'
[01:28:52.868] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:52.869] - Launch lazy future ...
[01:28:52.869] Packages needed by the future expression (n = 0): <none>
[01:28:52.869] Packages needed by future strategies (n = 0): <none>
[01:28:52.870] {
[01:28:52.870]     {
[01:28:52.870]         {
[01:28:52.870]             ...future.startTime <- base::Sys.time()
[01:28:52.870]             {
[01:28:52.870]                 {
[01:28:52.870]                   {
[01:28:52.870]                     base::local({
[01:28:52.870]                       has_future <- base::requireNamespace("future", 
[01:28:52.870]                         quietly = TRUE)
[01:28:52.870]                       if (has_future) {
[01:28:52.870]                         ns <- base::getNamespace("future")
[01:28:52.870]                         version <- ns[[".package"]][["version"]]
[01:28:52.870]                         if (is.null(version)) 
[01:28:52.870]                           version <- utils::packageVersion("future")
[01:28:52.870]                       }
[01:28:52.870]                       else {
[01:28:52.870]                         version <- NULL
[01:28:52.870]                       }
[01:28:52.870]                       if (!has_future || version < "1.8.0") {
[01:28:52.870]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:52.870]                           "", base::R.version$version.string), 
[01:28:52.870]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:52.870]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:52.870]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:52.870]                             "release", "version")], collapse = " "), 
[01:28:52.870]                           hostname = base::Sys.info()[["nodename"]])
[01:28:52.870]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:52.870]                           info)
[01:28:52.870]                         info <- base::paste(info, collapse = "; ")
[01:28:52.870]                         if (!has_future) {
[01:28:52.870]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:52.870]                             info)
[01:28:52.870]                         }
[01:28:52.870]                         else {
[01:28:52.870]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:52.870]                             info, version)
[01:28:52.870]                         }
[01:28:52.870]                         base::stop(msg)
[01:28:52.870]                       }
[01:28:52.870]                     })
[01:28:52.870]                   }
[01:28:52.870]                   options(future.plan = NULL)
[01:28:52.870]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:52.870]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:52.870]                 }
[01:28:52.870]                 ...future.workdir <- getwd()
[01:28:52.870]             }
[01:28:52.870]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:52.870]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:52.870]         }
[01:28:52.870]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:52.870]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:52.870]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:52.870]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:52.870]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:52.870]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:52.870]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:52.870]             base::names(...future.oldOptions))
[01:28:52.870]     }
[01:28:52.870]     if (FALSE) {
[01:28:52.870]     }
[01:28:52.870]     else {
[01:28:52.870]         if (TRUE) {
[01:28:52.870]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:52.870]                 open = "w")
[01:28:52.870]         }
[01:28:52.870]         else {
[01:28:52.870]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:52.870]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:52.870]         }
[01:28:52.870]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:52.870]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:52.870]             base::sink(type = "output", split = FALSE)
[01:28:52.870]             base::close(...future.stdout)
[01:28:52.870]         }, add = TRUE)
[01:28:52.870]     }
[01:28:52.870]     ...future.frame <- base::sys.nframe()
[01:28:52.870]     ...future.conditions <- base::list()
[01:28:52.870]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:52.870]     if (FALSE) {
[01:28:52.870]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:52.870]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:52.870]     }
[01:28:52.870]     ...future.result <- base::tryCatch({
[01:28:52.870]         base::withCallingHandlers({
[01:28:52.870]             ...future.value <- base::withVisible(base::local(2))
[01:28:52.870]             future::FutureResult(value = ...future.value$value, 
[01:28:52.870]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:52.870]                   ...future.rng), globalenv = if (FALSE) 
[01:28:52.870]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:52.870]                     ...future.globalenv.names))
[01:28:52.870]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:52.870]         }, condition = base::local({
[01:28:52.870]             c <- base::c
[01:28:52.870]             inherits <- base::inherits
[01:28:52.870]             invokeRestart <- base::invokeRestart
[01:28:52.870]             length <- base::length
[01:28:52.870]             list <- base::list
[01:28:52.870]             seq.int <- base::seq.int
[01:28:52.870]             signalCondition <- base::signalCondition
[01:28:52.870]             sys.calls <- base::sys.calls
[01:28:52.870]             `[[` <- base::`[[`
[01:28:52.870]             `+` <- base::`+`
[01:28:52.870]             `<<-` <- base::`<<-`
[01:28:52.870]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:52.870]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:52.870]                   3L)]
[01:28:52.870]             }
[01:28:52.870]             function(cond) {
[01:28:52.870]                 is_error <- inherits(cond, "error")
[01:28:52.870]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:52.870]                   NULL)
[01:28:52.870]                 if (is_error) {
[01:28:52.870]                   sessionInformation <- function() {
[01:28:52.870]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:52.870]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:52.870]                       search = base::search(), system = base::Sys.info())
[01:28:52.870]                   }
[01:28:52.870]                   ...future.conditions[[length(...future.conditions) + 
[01:28:52.870]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:52.870]                     cond$call), session = sessionInformation(), 
[01:28:52.870]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:52.870]                   signalCondition(cond)
[01:28:52.870]                 }
[01:28:52.870]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:52.870]                 "immediateCondition"))) {
[01:28:52.870]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:52.870]                   ...future.conditions[[length(...future.conditions) + 
[01:28:52.870]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:52.870]                   if (TRUE && !signal) {
[01:28:52.870]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:52.870]                     {
[01:28:52.870]                       inherits <- base::inherits
[01:28:52.870]                       invokeRestart <- base::invokeRestart
[01:28:52.870]                       is.null <- base::is.null
[01:28:52.870]                       muffled <- FALSE
[01:28:52.870]                       if (inherits(cond, "message")) {
[01:28:52.870]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:52.870]                         if (muffled) 
[01:28:52.870]                           invokeRestart("muffleMessage")
[01:28:52.870]                       }
[01:28:52.870]                       else if (inherits(cond, "warning")) {
[01:28:52.870]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:52.870]                         if (muffled) 
[01:28:52.870]                           invokeRestart("muffleWarning")
[01:28:52.870]                       }
[01:28:52.870]                       else if (inherits(cond, "condition")) {
[01:28:52.870]                         if (!is.null(pattern)) {
[01:28:52.870]                           computeRestarts <- base::computeRestarts
[01:28:52.870]                           grepl <- base::grepl
[01:28:52.870]                           restarts <- computeRestarts(cond)
[01:28:52.870]                           for (restart in restarts) {
[01:28:52.870]                             name <- restart$name
[01:28:52.870]                             if (is.null(name)) 
[01:28:52.870]                               next
[01:28:52.870]                             if (!grepl(pattern, name)) 
[01:28:52.870]                               next
[01:28:52.870]                             invokeRestart(restart)
[01:28:52.870]                             muffled <- TRUE
[01:28:52.870]                             break
[01:28:52.870]                           }
[01:28:52.870]                         }
[01:28:52.870]                       }
[01:28:52.870]                       invisible(muffled)
[01:28:52.870]                     }
[01:28:52.870]                     muffleCondition(cond, pattern = "^muffle")
[01:28:52.870]                   }
[01:28:52.870]                 }
[01:28:52.870]                 else {
[01:28:52.870]                   if (TRUE) {
[01:28:52.870]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:52.870]                     {
[01:28:52.870]                       inherits <- base::inherits
[01:28:52.870]                       invokeRestart <- base::invokeRestart
[01:28:52.870]                       is.null <- base::is.null
[01:28:52.870]                       muffled <- FALSE
[01:28:52.870]                       if (inherits(cond, "message")) {
[01:28:52.870]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:52.870]                         if (muffled) 
[01:28:52.870]                           invokeRestart("muffleMessage")
[01:28:52.870]                       }
[01:28:52.870]                       else if (inherits(cond, "warning")) {
[01:28:52.870]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:52.870]                         if (muffled) 
[01:28:52.870]                           invokeRestart("muffleWarning")
[01:28:52.870]                       }
[01:28:52.870]                       else if (inherits(cond, "condition")) {
[01:28:52.870]                         if (!is.null(pattern)) {
[01:28:52.870]                           computeRestarts <- base::computeRestarts
[01:28:52.870]                           grepl <- base::grepl
[01:28:52.870]                           restarts <- computeRestarts(cond)
[01:28:52.870]                           for (restart in restarts) {
[01:28:52.870]                             name <- restart$name
[01:28:52.870]                             if (is.null(name)) 
[01:28:52.870]                               next
[01:28:52.870]                             if (!grepl(pattern, name)) 
[01:28:52.870]                               next
[01:28:52.870]                             invokeRestart(restart)
[01:28:52.870]                             muffled <- TRUE
[01:28:52.870]                             break
[01:28:52.870]                           }
[01:28:52.870]                         }
[01:28:52.870]                       }
[01:28:52.870]                       invisible(muffled)
[01:28:52.870]                     }
[01:28:52.870]                     muffleCondition(cond, pattern = "^muffle")
[01:28:52.870]                   }
[01:28:52.870]                 }
[01:28:52.870]             }
[01:28:52.870]         }))
[01:28:52.870]     }, error = function(ex) {
[01:28:52.870]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:52.870]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:52.870]                 ...future.rng), started = ...future.startTime, 
[01:28:52.870]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:52.870]             version = "1.8"), class = "FutureResult")
[01:28:52.870]     }, finally = {
[01:28:52.870]         if (!identical(...future.workdir, getwd())) 
[01:28:52.870]             setwd(...future.workdir)
[01:28:52.870]         {
[01:28:52.870]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:52.870]                 ...future.oldOptions$nwarnings <- NULL
[01:28:52.870]             }
[01:28:52.870]             base::options(...future.oldOptions)
[01:28:52.870]             if (.Platform$OS.type == "windows") {
[01:28:52.870]                 old_names <- names(...future.oldEnvVars)
[01:28:52.870]                 envs <- base::Sys.getenv()
[01:28:52.870]                 names <- names(envs)
[01:28:52.870]                 common <- intersect(names, old_names)
[01:28:52.870]                 added <- setdiff(names, old_names)
[01:28:52.870]                 removed <- setdiff(old_names, names)
[01:28:52.870]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:52.870]                   envs[common]]
[01:28:52.870]                 NAMES <- toupper(changed)
[01:28:52.870]                 args <- list()
[01:28:52.870]                 for (kk in seq_along(NAMES)) {
[01:28:52.870]                   name <- changed[[kk]]
[01:28:52.870]                   NAME <- NAMES[[kk]]
[01:28:52.870]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:52.870]                     next
[01:28:52.870]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:52.870]                 }
[01:28:52.870]                 NAMES <- toupper(added)
[01:28:52.870]                 for (kk in seq_along(NAMES)) {
[01:28:52.870]                   name <- added[[kk]]
[01:28:52.870]                   NAME <- NAMES[[kk]]
[01:28:52.870]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:52.870]                     next
[01:28:52.870]                   args[[name]] <- ""
[01:28:52.870]                 }
[01:28:52.870]                 NAMES <- toupper(removed)
[01:28:52.870]                 for (kk in seq_along(NAMES)) {
[01:28:52.870]                   name <- removed[[kk]]
[01:28:52.870]                   NAME <- NAMES[[kk]]
[01:28:52.870]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:52.870]                     next
[01:28:52.870]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:52.870]                 }
[01:28:52.870]                 if (length(args) > 0) 
[01:28:52.870]                   base::do.call(base::Sys.setenv, args = args)
[01:28:52.870]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:52.870]             }
[01:28:52.870]             else {
[01:28:52.870]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:52.870]             }
[01:28:52.870]             {
[01:28:52.870]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:52.870]                   0L) {
[01:28:52.870]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:52.870]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:52.870]                   base::options(opts)
[01:28:52.870]                 }
[01:28:52.870]                 {
[01:28:52.870]                   {
[01:28:52.870]                     NULL
[01:28:52.870]                     RNGkind("Mersenne-Twister")
[01:28:52.870]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:52.870]                       inherits = FALSE)
[01:28:52.870]                   }
[01:28:52.870]                   options(future.plan = NULL)
[01:28:52.870]                   if (is.na(NA_character_)) 
[01:28:52.870]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:52.870]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:52.870]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:52.870]                   {
[01:28:52.870]                     future <- SequentialFuture(..., envir = envir)
[01:28:52.870]                     if (!future$lazy) 
[01:28:52.870]                       future <- run(future)
[01:28:52.870]                     invisible(future)
[01:28:52.870]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:52.870]                 }
[01:28:52.870]             }
[01:28:52.870]         }
[01:28:52.870]     })
[01:28:52.870]     if (TRUE) {
[01:28:52.870]         base::sink(type = "output", split = FALSE)
[01:28:52.870]         if (TRUE) {
[01:28:52.870]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:52.870]         }
[01:28:52.870]         else {
[01:28:52.870]             ...future.result["stdout"] <- base::list(NULL)
[01:28:52.870]         }
[01:28:52.870]         base::close(...future.stdout)
[01:28:52.870]         ...future.stdout <- NULL
[01:28:52.870]     }
[01:28:52.870]     ...future.result$conditions <- ...future.conditions
[01:28:52.870]     ...future.result$finished <- base::Sys.time()
[01:28:52.870]     ...future.result
[01:28:52.870] }
[01:28:52.876] plan(): Setting new future strategy stack:
[01:28:52.876] List of future strategies:
[01:28:52.876] 1. sequential:
[01:28:52.876]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:52.876]    - tweaked: FALSE
[01:28:52.876]    - call: NULL
[01:28:52.877] plan(): nbrOfWorkers() = 1
[01:28:52.879] plan(): Setting new future strategy stack:
[01:28:52.879] List of future strategies:
[01:28:52.879] 1. sequential:
[01:28:52.879]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:52.879]    - tweaked: FALSE
[01:28:52.879]    - call: plan(strategy)
[01:28:52.880] plan(): nbrOfWorkers() = 1
[01:28:52.880] SequentialFuture started (and completed)
[01:28:52.881] - Launch lazy future ... done
[01:28:52.881] run() for 'SequentialFuture' ... done
[01:28:52.881] resolve() on list ...
[01:28:52.881]  recursive: 0
[01:28:52.882]  length: 3
[01:28:52.882]  elements: 'a', 'b', ''
[01:28:52.882] run() for 'Future' ...
[01:28:52.882] - state: 'created'
[01:28:52.883] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:52.883] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:52.886] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:52.886]   - Field: 'label'
[01:28:52.886]   - Field: 'local'
[01:28:52.886]   - Field: 'owner'
[01:28:52.887]   - Field: 'envir'
[01:28:52.887]   - Field: 'packages'
[01:28:52.887]   - Field: 'gc'
[01:28:52.887]   - Field: 'conditions'
[01:28:52.888]   - Field: 'expr'
[01:28:52.888]   - Field: 'uuid'
[01:28:52.888]   - Field: 'seed'
[01:28:52.888]   - Field: 'version'
[01:28:52.889]   - Field: 'result'
[01:28:52.889]   - Field: 'asynchronous'
[01:28:52.889]   - Field: 'calls'
[01:28:52.890]   - Field: 'globals'
[01:28:52.890]   - Field: 'stdout'
[01:28:52.890]   - Field: 'earlySignal'
[01:28:52.890]   - Field: 'lazy'
[01:28:52.891]   - Field: 'state'
[01:28:52.891] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:52.891] - Launch lazy future ...
[01:28:52.891] Packages needed by the future expression (n = 0): <none>
[01:28:52.892] Packages needed by future strategies (n = 0): <none>
[01:28:52.893] {
[01:28:52.893]     {
[01:28:52.893]         {
[01:28:52.893]             ...future.startTime <- base::Sys.time()
[01:28:52.893]             {
[01:28:52.893]                 {
[01:28:52.893]                   {
[01:28:52.893]                     base::local({
[01:28:52.893]                       has_future <- base::requireNamespace("future", 
[01:28:52.893]                         quietly = TRUE)
[01:28:52.893]                       if (has_future) {
[01:28:52.893]                         ns <- base::getNamespace("future")
[01:28:52.893]                         version <- ns[[".package"]][["version"]]
[01:28:52.893]                         if (is.null(version)) 
[01:28:52.893]                           version <- utils::packageVersion("future")
[01:28:52.893]                       }
[01:28:52.893]                       else {
[01:28:52.893]                         version <- NULL
[01:28:52.893]                       }
[01:28:52.893]                       if (!has_future || version < "1.8.0") {
[01:28:52.893]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:52.893]                           "", base::R.version$version.string), 
[01:28:52.893]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:52.893]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:52.893]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:52.893]                             "release", "version")], collapse = " "), 
[01:28:52.893]                           hostname = base::Sys.info()[["nodename"]])
[01:28:52.893]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:52.893]                           info)
[01:28:52.893]                         info <- base::paste(info, collapse = "; ")
[01:28:52.893]                         if (!has_future) {
[01:28:52.893]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:52.893]                             info)
[01:28:52.893]                         }
[01:28:52.893]                         else {
[01:28:52.893]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:52.893]                             info, version)
[01:28:52.893]                         }
[01:28:52.893]                         base::stop(msg)
[01:28:52.893]                       }
[01:28:52.893]                     })
[01:28:52.893]                   }
[01:28:52.893]                   options(future.plan = NULL)
[01:28:52.893]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:52.893]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:52.893]                 }
[01:28:52.893]                 ...future.workdir <- getwd()
[01:28:52.893]             }
[01:28:52.893]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:52.893]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:52.893]         }
[01:28:52.893]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:52.893]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:52.893]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:52.893]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:52.893]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:52.893]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:52.893]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:52.893]             base::names(...future.oldOptions))
[01:28:52.893]     }
[01:28:52.893]     if (FALSE) {
[01:28:52.893]     }
[01:28:52.893]     else {
[01:28:52.893]         if (TRUE) {
[01:28:52.893]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:52.893]                 open = "w")
[01:28:52.893]         }
[01:28:52.893]         else {
[01:28:52.893]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:52.893]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:52.893]         }
[01:28:52.893]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:52.893]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:52.893]             base::sink(type = "output", split = FALSE)
[01:28:52.893]             base::close(...future.stdout)
[01:28:52.893]         }, add = TRUE)
[01:28:52.893]     }
[01:28:52.893]     ...future.frame <- base::sys.nframe()
[01:28:52.893]     ...future.conditions <- base::list()
[01:28:52.893]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:52.893]     if (FALSE) {
[01:28:52.893]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:52.893]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:52.893]     }
[01:28:52.893]     ...future.result <- base::tryCatch({
[01:28:52.893]         base::withCallingHandlers({
[01:28:52.893]             ...future.value <- base::withVisible(base::local(1))
[01:28:52.893]             future::FutureResult(value = ...future.value$value, 
[01:28:52.893]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:52.893]                   ...future.rng), globalenv = if (FALSE) 
[01:28:52.893]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:52.893]                     ...future.globalenv.names))
[01:28:52.893]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:52.893]         }, condition = base::local({
[01:28:52.893]             c <- base::c
[01:28:52.893]             inherits <- base::inherits
[01:28:52.893]             invokeRestart <- base::invokeRestart
[01:28:52.893]             length <- base::length
[01:28:52.893]             list <- base::list
[01:28:52.893]             seq.int <- base::seq.int
[01:28:52.893]             signalCondition <- base::signalCondition
[01:28:52.893]             sys.calls <- base::sys.calls
[01:28:52.893]             `[[` <- base::`[[`
[01:28:52.893]             `+` <- base::`+`
[01:28:52.893]             `<<-` <- base::`<<-`
[01:28:52.893]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:52.893]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:52.893]                   3L)]
[01:28:52.893]             }
[01:28:52.893]             function(cond) {
[01:28:52.893]                 is_error <- inherits(cond, "error")
[01:28:52.893]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:52.893]                   NULL)
[01:28:52.893]                 if (is_error) {
[01:28:52.893]                   sessionInformation <- function() {
[01:28:52.893]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:52.893]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:52.893]                       search = base::search(), system = base::Sys.info())
[01:28:52.893]                   }
[01:28:52.893]                   ...future.conditions[[length(...future.conditions) + 
[01:28:52.893]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:52.893]                     cond$call), session = sessionInformation(), 
[01:28:52.893]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:52.893]                   signalCondition(cond)
[01:28:52.893]                 }
[01:28:52.893]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:52.893]                 "immediateCondition"))) {
[01:28:52.893]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:52.893]                   ...future.conditions[[length(...future.conditions) + 
[01:28:52.893]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:52.893]                   if (TRUE && !signal) {
[01:28:52.893]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:52.893]                     {
[01:28:52.893]                       inherits <- base::inherits
[01:28:52.893]                       invokeRestart <- base::invokeRestart
[01:28:52.893]                       is.null <- base::is.null
[01:28:52.893]                       muffled <- FALSE
[01:28:52.893]                       if (inherits(cond, "message")) {
[01:28:52.893]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:52.893]                         if (muffled) 
[01:28:52.893]                           invokeRestart("muffleMessage")
[01:28:52.893]                       }
[01:28:52.893]                       else if (inherits(cond, "warning")) {
[01:28:52.893]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:52.893]                         if (muffled) 
[01:28:52.893]                           invokeRestart("muffleWarning")
[01:28:52.893]                       }
[01:28:52.893]                       else if (inherits(cond, "condition")) {
[01:28:52.893]                         if (!is.null(pattern)) {
[01:28:52.893]                           computeRestarts <- base::computeRestarts
[01:28:52.893]                           grepl <- base::grepl
[01:28:52.893]                           restarts <- computeRestarts(cond)
[01:28:52.893]                           for (restart in restarts) {
[01:28:52.893]                             name <- restart$name
[01:28:52.893]                             if (is.null(name)) 
[01:28:52.893]                               next
[01:28:52.893]                             if (!grepl(pattern, name)) 
[01:28:52.893]                               next
[01:28:52.893]                             invokeRestart(restart)
[01:28:52.893]                             muffled <- TRUE
[01:28:52.893]                             break
[01:28:52.893]                           }
[01:28:52.893]                         }
[01:28:52.893]                       }
[01:28:52.893]                       invisible(muffled)
[01:28:52.893]                     }
[01:28:52.893]                     muffleCondition(cond, pattern = "^muffle")
[01:28:52.893]                   }
[01:28:52.893]                 }
[01:28:52.893]                 else {
[01:28:52.893]                   if (TRUE) {
[01:28:52.893]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:52.893]                     {
[01:28:52.893]                       inherits <- base::inherits
[01:28:52.893]                       invokeRestart <- base::invokeRestart
[01:28:52.893]                       is.null <- base::is.null
[01:28:52.893]                       muffled <- FALSE
[01:28:52.893]                       if (inherits(cond, "message")) {
[01:28:52.893]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:52.893]                         if (muffled) 
[01:28:52.893]                           invokeRestart("muffleMessage")
[01:28:52.893]                       }
[01:28:52.893]                       else if (inherits(cond, "warning")) {
[01:28:52.893]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:52.893]                         if (muffled) 
[01:28:52.893]                           invokeRestart("muffleWarning")
[01:28:52.893]                       }
[01:28:52.893]                       else if (inherits(cond, "condition")) {
[01:28:52.893]                         if (!is.null(pattern)) {
[01:28:52.893]                           computeRestarts <- base::computeRestarts
[01:28:52.893]                           grepl <- base::grepl
[01:28:52.893]                           restarts <- computeRestarts(cond)
[01:28:52.893]                           for (restart in restarts) {
[01:28:52.893]                             name <- restart$name
[01:28:52.893]                             if (is.null(name)) 
[01:28:52.893]                               next
[01:28:52.893]                             if (!grepl(pattern, name)) 
[01:28:52.893]                               next
[01:28:52.893]                             invokeRestart(restart)
[01:28:52.893]                             muffled <- TRUE
[01:28:52.893]                             break
[01:28:52.893]                           }
[01:28:52.893]                         }
[01:28:52.893]                       }
[01:28:52.893]                       invisible(muffled)
[01:28:52.893]                     }
[01:28:52.893]                     muffleCondition(cond, pattern = "^muffle")
[01:28:52.893]                   }
[01:28:52.893]                 }
[01:28:52.893]             }
[01:28:52.893]         }))
[01:28:52.893]     }, error = function(ex) {
[01:28:52.893]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:52.893]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:52.893]                 ...future.rng), started = ...future.startTime, 
[01:28:52.893]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:52.893]             version = "1.8"), class = "FutureResult")
[01:28:52.893]     }, finally = {
[01:28:52.893]         if (!identical(...future.workdir, getwd())) 
[01:28:52.893]             setwd(...future.workdir)
[01:28:52.893]         {
[01:28:52.893]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:52.893]                 ...future.oldOptions$nwarnings <- NULL
[01:28:52.893]             }
[01:28:52.893]             base::options(...future.oldOptions)
[01:28:52.893]             if (.Platform$OS.type == "windows") {
[01:28:52.893]                 old_names <- names(...future.oldEnvVars)
[01:28:52.893]                 envs <- base::Sys.getenv()
[01:28:52.893]                 names <- names(envs)
[01:28:52.893]                 common <- intersect(names, old_names)
[01:28:52.893]                 added <- setdiff(names, old_names)
[01:28:52.893]                 removed <- setdiff(old_names, names)
[01:28:52.893]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:52.893]                   envs[common]]
[01:28:52.893]                 NAMES <- toupper(changed)
[01:28:52.893]                 args <- list()
[01:28:52.893]                 for (kk in seq_along(NAMES)) {
[01:28:52.893]                   name <- changed[[kk]]
[01:28:52.893]                   NAME <- NAMES[[kk]]
[01:28:52.893]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:52.893]                     next
[01:28:52.893]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:52.893]                 }
[01:28:52.893]                 NAMES <- toupper(added)
[01:28:52.893]                 for (kk in seq_along(NAMES)) {
[01:28:52.893]                   name <- added[[kk]]
[01:28:52.893]                   NAME <- NAMES[[kk]]
[01:28:52.893]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:52.893]                     next
[01:28:52.893]                   args[[name]] <- ""
[01:28:52.893]                 }
[01:28:52.893]                 NAMES <- toupper(removed)
[01:28:52.893]                 for (kk in seq_along(NAMES)) {
[01:28:52.893]                   name <- removed[[kk]]
[01:28:52.893]                   NAME <- NAMES[[kk]]
[01:28:52.893]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:52.893]                     next
[01:28:52.893]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:52.893]                 }
[01:28:52.893]                 if (length(args) > 0) 
[01:28:52.893]                   base::do.call(base::Sys.setenv, args = args)
[01:28:52.893]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:52.893]             }
[01:28:52.893]             else {
[01:28:52.893]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:52.893]             }
[01:28:52.893]             {
[01:28:52.893]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:52.893]                   0L) {
[01:28:52.893]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:52.893]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:52.893]                   base::options(opts)
[01:28:52.893]                 }
[01:28:52.893]                 {
[01:28:52.893]                   {
[01:28:52.893]                     NULL
[01:28:52.893]                     RNGkind("Mersenne-Twister")
[01:28:52.893]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:52.893]                       inherits = FALSE)
[01:28:52.893]                   }
[01:28:52.893]                   options(future.plan = NULL)
[01:28:52.893]                   if (is.na(NA_character_)) 
[01:28:52.893]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:52.893]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:52.893]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:52.893]                   {
[01:28:52.893]                     future <- SequentialFuture(..., envir = envir)
[01:28:52.893]                     if (!future$lazy) 
[01:28:52.893]                       future <- run(future)
[01:28:52.893]                     invisible(future)
[01:28:52.893]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:52.893]                 }
[01:28:52.893]             }
[01:28:52.893]         }
[01:28:52.893]     })
[01:28:52.893]     if (TRUE) {
[01:28:52.893]         base::sink(type = "output", split = FALSE)
[01:28:52.893]         if (TRUE) {
[01:28:52.893]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:52.893]         }
[01:28:52.893]         else {
[01:28:52.893]             ...future.result["stdout"] <- base::list(NULL)
[01:28:52.893]         }
[01:28:52.893]         base::close(...future.stdout)
[01:28:52.893]         ...future.stdout <- NULL
[01:28:52.893]     }
[01:28:52.893]     ...future.result$conditions <- ...future.conditions
[01:28:52.893]     ...future.result$finished <- base::Sys.time()
[01:28:52.893]     ...future.result
[01:28:52.893] }
[01:28:52.897] plan(): Setting new future strategy stack:
[01:28:52.898] List of future strategies:
[01:28:52.898] 1. sequential:
[01:28:52.898]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:52.898]    - tweaked: FALSE
[01:28:52.898]    - call: NULL
[01:28:52.899] plan(): nbrOfWorkers() = 1
[01:28:52.900] plan(): Setting new future strategy stack:
[01:28:52.900] List of future strategies:
[01:28:52.900] 1. sequential:
[01:28:52.900]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:52.900]    - tweaked: FALSE
[01:28:52.900]    - call: plan(strategy)
[01:28:52.901] plan(): nbrOfWorkers() = 1
[01:28:52.902] SequentialFuture started (and completed)
[01:28:52.902] - Launch lazy future ... done
[01:28:52.903] run() for 'SequentialFuture' ... done
[01:28:52.903] resolved() for 'SequentialFuture' ...
[01:28:52.903] - state: 'finished'
[01:28:52.904] - run: TRUE
[01:28:52.904] - result: 'FutureResult'
[01:28:52.904] resolved() for 'SequentialFuture' ... done
[01:28:52.904] Future #1
[01:28:52.905]  length: 2 (resolved future 1)
[01:28:52.905] resolved() for 'SequentialFuture' ...
[01:28:52.906] - state: 'finished'
[01:28:52.906] - run: TRUE
[01:28:52.906] - result: 'FutureResult'
[01:28:52.906] resolved() for 'SequentialFuture' ... done
[01:28:52.907] Future #2
[01:28:52.907]  length: 1 (resolved future 2)
[01:28:52.907]  length: 0 (resolved future 3)
[01:28:52.907] resolve() on list ... DONE
[01:28:52.908] resolved() for 'SequentialFuture' ...
[01:28:52.908] - state: 'finished'
[01:28:52.908] - run: TRUE
[01:28:52.908] - result: 'FutureResult'
[01:28:52.909] resolved() for 'SequentialFuture' ... done
[01:28:52.909] resolved() for 'SequentialFuture' ...
[01:28:52.909] - state: 'finished'
[01:28:52.910] - run: TRUE
[01:28:52.910] - result: 'FutureResult'
[01:28:52.910] resolved() for 'SequentialFuture' ... done
[01:28:52.911] getGlobalsAndPackages() ...
[01:28:52.911] Searching for globals...
[01:28:52.911] 
[01:28:52.912] Searching for globals ... DONE
[01:28:52.912] - globals: [0] <none>
[01:28:52.912] getGlobalsAndPackages() ... DONE
[01:28:52.913] getGlobalsAndPackages() ...
[01:28:52.913] Searching for globals...
[01:28:52.914] 
[01:28:52.914] Searching for globals ... DONE
[01:28:52.914] - globals: [0] <none>
[01:28:52.914] getGlobalsAndPackages() ... DONE
[01:28:52.915] resolve() on list ...
[01:28:52.915]  recursive: 0
[01:28:52.915]  length: 3
[01:28:52.916]  elements: 'a', 'b', ''
[01:28:52.916] run() for 'Future' ...
[01:28:52.916] - state: 'created'
[01:28:52.917] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:52.917] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:52.918] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:52.918]   - Field: 'label'
[01:28:52.918]   - Field: 'local'
[01:28:52.919]   - Field: 'owner'
[01:28:52.919]   - Field: 'envir'
[01:28:52.919]   - Field: 'packages'
[01:28:52.920]   - Field: 'gc'
[01:28:52.920]   - Field: 'conditions'
[01:28:52.920]   - Field: 'expr'
[01:28:52.920]   - Field: 'uuid'
[01:28:52.921]   - Field: 'seed'
[01:28:52.921]   - Field: 'version'
[01:28:52.921]   - Field: 'result'
[01:28:52.922]   - Field: 'asynchronous'
[01:28:52.922]   - Field: 'calls'
[01:28:52.922]   - Field: 'globals'
[01:28:52.922]   - Field: 'stdout'
[01:28:52.923]   - Field: 'earlySignal'
[01:28:52.923]   - Field: 'lazy'
[01:28:52.923]   - Field: 'state'
[01:28:52.924] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:52.924] - Launch lazy future ...
[01:28:52.924] Packages needed by the future expression (n = 0): <none>
[01:28:52.924] Packages needed by future strategies (n = 0): <none>
[01:28:52.925] {
[01:28:52.925]     {
[01:28:52.925]         {
[01:28:52.925]             ...future.startTime <- base::Sys.time()
[01:28:52.925]             {
[01:28:52.925]                 {
[01:28:52.925]                   {
[01:28:52.925]                     base::local({
[01:28:52.925]                       has_future <- base::requireNamespace("future", 
[01:28:52.925]                         quietly = TRUE)
[01:28:52.925]                       if (has_future) {
[01:28:52.925]                         ns <- base::getNamespace("future")
[01:28:52.925]                         version <- ns[[".package"]][["version"]]
[01:28:52.925]                         if (is.null(version)) 
[01:28:52.925]                           version <- utils::packageVersion("future")
[01:28:52.925]                       }
[01:28:52.925]                       else {
[01:28:52.925]                         version <- NULL
[01:28:52.925]                       }
[01:28:52.925]                       if (!has_future || version < "1.8.0") {
[01:28:52.925]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:52.925]                           "", base::R.version$version.string), 
[01:28:52.925]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:52.925]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:52.925]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:52.925]                             "release", "version")], collapse = " "), 
[01:28:52.925]                           hostname = base::Sys.info()[["nodename"]])
[01:28:52.925]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:52.925]                           info)
[01:28:52.925]                         info <- base::paste(info, collapse = "; ")
[01:28:52.925]                         if (!has_future) {
[01:28:52.925]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:52.925]                             info)
[01:28:52.925]                         }
[01:28:52.925]                         else {
[01:28:52.925]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:52.925]                             info, version)
[01:28:52.925]                         }
[01:28:52.925]                         base::stop(msg)
[01:28:52.925]                       }
[01:28:52.925]                     })
[01:28:52.925]                   }
[01:28:52.925]                   options(future.plan = NULL)
[01:28:52.925]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:52.925]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:52.925]                 }
[01:28:52.925]                 ...future.workdir <- getwd()
[01:28:52.925]             }
[01:28:52.925]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:52.925]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:52.925]         }
[01:28:52.925]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:52.925]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:52.925]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:52.925]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:52.925]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:52.925]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:52.925]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:52.925]             base::names(...future.oldOptions))
[01:28:52.925]     }
[01:28:52.925]     if (FALSE) {
[01:28:52.925]     }
[01:28:52.925]     else {
[01:28:52.925]         if (TRUE) {
[01:28:52.925]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:52.925]                 open = "w")
[01:28:52.925]         }
[01:28:52.925]         else {
[01:28:52.925]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:52.925]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:52.925]         }
[01:28:52.925]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:52.925]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:52.925]             base::sink(type = "output", split = FALSE)
[01:28:52.925]             base::close(...future.stdout)
[01:28:52.925]         }, add = TRUE)
[01:28:52.925]     }
[01:28:52.925]     ...future.frame <- base::sys.nframe()
[01:28:52.925]     ...future.conditions <- base::list()
[01:28:52.925]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:52.925]     if (FALSE) {
[01:28:52.925]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:52.925]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:52.925]     }
[01:28:52.925]     ...future.result <- base::tryCatch({
[01:28:52.925]         base::withCallingHandlers({
[01:28:52.925]             ...future.value <- base::withVisible(base::local(1))
[01:28:52.925]             future::FutureResult(value = ...future.value$value, 
[01:28:52.925]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:52.925]                   ...future.rng), globalenv = if (FALSE) 
[01:28:52.925]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:52.925]                     ...future.globalenv.names))
[01:28:52.925]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:52.925]         }, condition = base::local({
[01:28:52.925]             c <- base::c
[01:28:52.925]             inherits <- base::inherits
[01:28:52.925]             invokeRestart <- base::invokeRestart
[01:28:52.925]             length <- base::length
[01:28:52.925]             list <- base::list
[01:28:52.925]             seq.int <- base::seq.int
[01:28:52.925]             signalCondition <- base::signalCondition
[01:28:52.925]             sys.calls <- base::sys.calls
[01:28:52.925]             `[[` <- base::`[[`
[01:28:52.925]             `+` <- base::`+`
[01:28:52.925]             `<<-` <- base::`<<-`
[01:28:52.925]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:52.925]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:52.925]                   3L)]
[01:28:52.925]             }
[01:28:52.925]             function(cond) {
[01:28:52.925]                 is_error <- inherits(cond, "error")
[01:28:52.925]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:52.925]                   NULL)
[01:28:52.925]                 if (is_error) {
[01:28:52.925]                   sessionInformation <- function() {
[01:28:52.925]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:52.925]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:52.925]                       search = base::search(), system = base::Sys.info())
[01:28:52.925]                   }
[01:28:52.925]                   ...future.conditions[[length(...future.conditions) + 
[01:28:52.925]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:52.925]                     cond$call), session = sessionInformation(), 
[01:28:52.925]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:52.925]                   signalCondition(cond)
[01:28:52.925]                 }
[01:28:52.925]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:52.925]                 "immediateCondition"))) {
[01:28:52.925]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:52.925]                   ...future.conditions[[length(...future.conditions) + 
[01:28:52.925]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:52.925]                   if (TRUE && !signal) {
[01:28:52.925]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:52.925]                     {
[01:28:52.925]                       inherits <- base::inherits
[01:28:52.925]                       invokeRestart <- base::invokeRestart
[01:28:52.925]                       is.null <- base::is.null
[01:28:52.925]                       muffled <- FALSE
[01:28:52.925]                       if (inherits(cond, "message")) {
[01:28:52.925]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:52.925]                         if (muffled) 
[01:28:52.925]                           invokeRestart("muffleMessage")
[01:28:52.925]                       }
[01:28:52.925]                       else if (inherits(cond, "warning")) {
[01:28:52.925]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:52.925]                         if (muffled) 
[01:28:52.925]                           invokeRestart("muffleWarning")
[01:28:52.925]                       }
[01:28:52.925]                       else if (inherits(cond, "condition")) {
[01:28:52.925]                         if (!is.null(pattern)) {
[01:28:52.925]                           computeRestarts <- base::computeRestarts
[01:28:52.925]                           grepl <- base::grepl
[01:28:52.925]                           restarts <- computeRestarts(cond)
[01:28:52.925]                           for (restart in restarts) {
[01:28:52.925]                             name <- restart$name
[01:28:52.925]                             if (is.null(name)) 
[01:28:52.925]                               next
[01:28:52.925]                             if (!grepl(pattern, name)) 
[01:28:52.925]                               next
[01:28:52.925]                             invokeRestart(restart)
[01:28:52.925]                             muffled <- TRUE
[01:28:52.925]                             break
[01:28:52.925]                           }
[01:28:52.925]                         }
[01:28:52.925]                       }
[01:28:52.925]                       invisible(muffled)
[01:28:52.925]                     }
[01:28:52.925]                     muffleCondition(cond, pattern = "^muffle")
[01:28:52.925]                   }
[01:28:52.925]                 }
[01:28:52.925]                 else {
[01:28:52.925]                   if (TRUE) {
[01:28:52.925]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:52.925]                     {
[01:28:52.925]                       inherits <- base::inherits
[01:28:52.925]                       invokeRestart <- base::invokeRestart
[01:28:52.925]                       is.null <- base::is.null
[01:28:52.925]                       muffled <- FALSE
[01:28:52.925]                       if (inherits(cond, "message")) {
[01:28:52.925]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:52.925]                         if (muffled) 
[01:28:52.925]                           invokeRestart("muffleMessage")
[01:28:52.925]                       }
[01:28:52.925]                       else if (inherits(cond, "warning")) {
[01:28:52.925]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:52.925]                         if (muffled) 
[01:28:52.925]                           invokeRestart("muffleWarning")
[01:28:52.925]                       }
[01:28:52.925]                       else if (inherits(cond, "condition")) {
[01:28:52.925]                         if (!is.null(pattern)) {
[01:28:52.925]                           computeRestarts <- base::computeRestarts
[01:28:52.925]                           grepl <- base::grepl
[01:28:52.925]                           restarts <- computeRestarts(cond)
[01:28:52.925]                           for (restart in restarts) {
[01:28:52.925]                             name <- restart$name
[01:28:52.925]                             if (is.null(name)) 
[01:28:52.925]                               next
[01:28:52.925]                             if (!grepl(pattern, name)) 
[01:28:52.925]                               next
[01:28:52.925]                             invokeRestart(restart)
[01:28:52.925]                             muffled <- TRUE
[01:28:52.925]                             break
[01:28:52.925]                           }
[01:28:52.925]                         }
[01:28:52.925]                       }
[01:28:52.925]                       invisible(muffled)
[01:28:52.925]                     }
[01:28:52.925]                     muffleCondition(cond, pattern = "^muffle")
[01:28:52.925]                   }
[01:28:52.925]                 }
[01:28:52.925]             }
[01:28:52.925]         }))
[01:28:52.925]     }, error = function(ex) {
[01:28:52.925]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:52.925]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:52.925]                 ...future.rng), started = ...future.startTime, 
[01:28:52.925]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:52.925]             version = "1.8"), class = "FutureResult")
[01:28:52.925]     }, finally = {
[01:28:52.925]         if (!identical(...future.workdir, getwd())) 
[01:28:52.925]             setwd(...future.workdir)
[01:28:52.925]         {
[01:28:52.925]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:52.925]                 ...future.oldOptions$nwarnings <- NULL
[01:28:52.925]             }
[01:28:52.925]             base::options(...future.oldOptions)
[01:28:52.925]             if (.Platform$OS.type == "windows") {
[01:28:52.925]                 old_names <- names(...future.oldEnvVars)
[01:28:52.925]                 envs <- base::Sys.getenv()
[01:28:52.925]                 names <- names(envs)
[01:28:52.925]                 common <- intersect(names, old_names)
[01:28:52.925]                 added <- setdiff(names, old_names)
[01:28:52.925]                 removed <- setdiff(old_names, names)
[01:28:52.925]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:52.925]                   envs[common]]
[01:28:52.925]                 NAMES <- toupper(changed)
[01:28:52.925]                 args <- list()
[01:28:52.925]                 for (kk in seq_along(NAMES)) {
[01:28:52.925]                   name <- changed[[kk]]
[01:28:52.925]                   NAME <- NAMES[[kk]]
[01:28:52.925]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:52.925]                     next
[01:28:52.925]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:52.925]                 }
[01:28:52.925]                 NAMES <- toupper(added)
[01:28:52.925]                 for (kk in seq_along(NAMES)) {
[01:28:52.925]                   name <- added[[kk]]
[01:28:52.925]                   NAME <- NAMES[[kk]]
[01:28:52.925]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:52.925]                     next
[01:28:52.925]                   args[[name]] <- ""
[01:28:52.925]                 }
[01:28:52.925]                 NAMES <- toupper(removed)
[01:28:52.925]                 for (kk in seq_along(NAMES)) {
[01:28:52.925]                   name <- removed[[kk]]
[01:28:52.925]                   NAME <- NAMES[[kk]]
[01:28:52.925]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:52.925]                     next
[01:28:52.925]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:52.925]                 }
[01:28:52.925]                 if (length(args) > 0) 
[01:28:52.925]                   base::do.call(base::Sys.setenv, args = args)
[01:28:52.925]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:52.925]             }
[01:28:52.925]             else {
[01:28:52.925]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:52.925]             }
[01:28:52.925]             {
[01:28:52.925]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:52.925]                   0L) {
[01:28:52.925]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:52.925]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:52.925]                   base::options(opts)
[01:28:52.925]                 }
[01:28:52.925]                 {
[01:28:52.925]                   {
[01:28:52.925]                     NULL
[01:28:52.925]                     RNGkind("Mersenne-Twister")
[01:28:52.925]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:52.925]                       inherits = FALSE)
[01:28:52.925]                   }
[01:28:52.925]                   options(future.plan = NULL)
[01:28:52.925]                   if (is.na(NA_character_)) 
[01:28:52.925]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:52.925]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:52.925]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:52.925]                   {
[01:28:52.925]                     future <- SequentialFuture(..., envir = envir)
[01:28:52.925]                     if (!future$lazy) 
[01:28:52.925]                       future <- run(future)
[01:28:52.925]                     invisible(future)
[01:28:52.925]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:52.925]                 }
[01:28:52.925]             }
[01:28:52.925]         }
[01:28:52.925]     })
[01:28:52.925]     if (TRUE) {
[01:28:52.925]         base::sink(type = "output", split = FALSE)
[01:28:52.925]         if (TRUE) {
[01:28:52.925]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:52.925]         }
[01:28:52.925]         else {
[01:28:52.925]             ...future.result["stdout"] <- base::list(NULL)
[01:28:52.925]         }
[01:28:52.925]         base::close(...future.stdout)
[01:28:52.925]         ...future.stdout <- NULL
[01:28:52.925]     }
[01:28:52.925]     ...future.result$conditions <- ...future.conditions
[01:28:52.925]     ...future.result$finished <- base::Sys.time()
[01:28:52.925]     ...future.result
[01:28:52.925] }
[01:28:52.930] plan(): Setting new future strategy stack:
[01:28:52.931] List of future strategies:
[01:28:52.931] 1. sequential:
[01:28:52.931]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:52.931]    - tweaked: FALSE
[01:28:52.931]    - call: NULL
[01:28:52.932] plan(): nbrOfWorkers() = 1
[01:28:52.933] plan(): Setting new future strategy stack:
[01:28:52.933] List of future strategies:
[01:28:52.933] 1. sequential:
[01:28:52.933]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:52.933]    - tweaked: FALSE
[01:28:52.933]    - call: plan(strategy)
[01:28:52.934] plan(): nbrOfWorkers() = 1
[01:28:52.935] SequentialFuture started (and completed)
[01:28:52.935] - Launch lazy future ... done
[01:28:52.935] run() for 'SequentialFuture' ... done
[01:28:52.936] resolved() for 'SequentialFuture' ...
[01:28:52.936] - state: 'finished'
[01:28:52.936] - run: TRUE
[01:28:52.936] - result: 'FutureResult'
[01:28:52.937] resolved() for 'SequentialFuture' ... done
[01:28:52.937] Future #1
[01:28:52.937]  length: 2 (resolved future 1)
[01:28:52.937] run() for 'Future' ...
[01:28:52.938] - state: 'created'
[01:28:52.938] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:52.939] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:52.939] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:52.939]   - Field: 'label'
[01:28:52.939]   - Field: 'local'
[01:28:52.940]   - Field: 'owner'
[01:28:52.940]   - Field: 'envir'
[01:28:52.940]   - Field: 'packages'
[01:28:52.940]   - Field: 'gc'
[01:28:52.941]   - Field: 'conditions'
[01:28:52.941]   - Field: 'expr'
[01:28:52.941]   - Field: 'uuid'
[01:28:52.941]   - Field: 'seed'
[01:28:52.942]   - Field: 'version'
[01:28:52.942]   - Field: 'result'
[01:28:52.942]   - Field: 'asynchronous'
[01:28:52.942]   - Field: 'calls'
[01:28:52.943]   - Field: 'globals'
[01:28:52.943]   - Field: 'stdout'
[01:28:52.943]   - Field: 'earlySignal'
[01:28:52.944]   - Field: 'lazy'
[01:28:52.944]   - Field: 'state'
[01:28:52.944] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:52.944] - Launch lazy future ...
[01:28:52.945] Packages needed by the future expression (n = 0): <none>
[01:28:52.945] Packages needed by future strategies (n = 0): <none>
[01:28:52.946] {
[01:28:52.946]     {
[01:28:52.946]         {
[01:28:52.946]             ...future.startTime <- base::Sys.time()
[01:28:52.946]             {
[01:28:52.946]                 {
[01:28:52.946]                   {
[01:28:52.946]                     base::local({
[01:28:52.946]                       has_future <- base::requireNamespace("future", 
[01:28:52.946]                         quietly = TRUE)
[01:28:52.946]                       if (has_future) {
[01:28:52.946]                         ns <- base::getNamespace("future")
[01:28:52.946]                         version <- ns[[".package"]][["version"]]
[01:28:52.946]                         if (is.null(version)) 
[01:28:52.946]                           version <- utils::packageVersion("future")
[01:28:52.946]                       }
[01:28:52.946]                       else {
[01:28:52.946]                         version <- NULL
[01:28:52.946]                       }
[01:28:52.946]                       if (!has_future || version < "1.8.0") {
[01:28:52.946]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:52.946]                           "", base::R.version$version.string), 
[01:28:52.946]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:52.946]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:52.946]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:52.946]                             "release", "version")], collapse = " "), 
[01:28:52.946]                           hostname = base::Sys.info()[["nodename"]])
[01:28:52.946]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:52.946]                           info)
[01:28:52.946]                         info <- base::paste(info, collapse = "; ")
[01:28:52.946]                         if (!has_future) {
[01:28:52.946]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:52.946]                             info)
[01:28:52.946]                         }
[01:28:52.946]                         else {
[01:28:52.946]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:52.946]                             info, version)
[01:28:52.946]                         }
[01:28:52.946]                         base::stop(msg)
[01:28:52.946]                       }
[01:28:52.946]                     })
[01:28:52.946]                   }
[01:28:52.946]                   options(future.plan = NULL)
[01:28:52.946]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:52.946]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:52.946]                 }
[01:28:52.946]                 ...future.workdir <- getwd()
[01:28:52.946]             }
[01:28:52.946]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:52.946]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:52.946]         }
[01:28:52.946]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:52.946]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:52.946]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:52.946]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:52.946]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:52.946]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:52.946]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:52.946]             base::names(...future.oldOptions))
[01:28:52.946]     }
[01:28:52.946]     if (FALSE) {
[01:28:52.946]     }
[01:28:52.946]     else {
[01:28:52.946]         if (TRUE) {
[01:28:52.946]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:52.946]                 open = "w")
[01:28:52.946]         }
[01:28:52.946]         else {
[01:28:52.946]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:52.946]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:52.946]         }
[01:28:52.946]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:52.946]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:52.946]             base::sink(type = "output", split = FALSE)
[01:28:52.946]             base::close(...future.stdout)
[01:28:52.946]         }, add = TRUE)
[01:28:52.946]     }
[01:28:52.946]     ...future.frame <- base::sys.nframe()
[01:28:52.946]     ...future.conditions <- base::list()
[01:28:52.946]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:52.946]     if (FALSE) {
[01:28:52.946]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:52.946]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:52.946]     }
[01:28:52.946]     ...future.result <- base::tryCatch({
[01:28:52.946]         base::withCallingHandlers({
[01:28:52.946]             ...future.value <- base::withVisible(base::local(2))
[01:28:52.946]             future::FutureResult(value = ...future.value$value, 
[01:28:52.946]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:52.946]                   ...future.rng), globalenv = if (FALSE) 
[01:28:52.946]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:52.946]                     ...future.globalenv.names))
[01:28:52.946]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:52.946]         }, condition = base::local({
[01:28:52.946]             c <- base::c
[01:28:52.946]             inherits <- base::inherits
[01:28:52.946]             invokeRestart <- base::invokeRestart
[01:28:52.946]             length <- base::length
[01:28:52.946]             list <- base::list
[01:28:52.946]             seq.int <- base::seq.int
[01:28:52.946]             signalCondition <- base::signalCondition
[01:28:52.946]             sys.calls <- base::sys.calls
[01:28:52.946]             `[[` <- base::`[[`
[01:28:52.946]             `+` <- base::`+`
[01:28:52.946]             `<<-` <- base::`<<-`
[01:28:52.946]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:52.946]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:52.946]                   3L)]
[01:28:52.946]             }
[01:28:52.946]             function(cond) {
[01:28:52.946]                 is_error <- inherits(cond, "error")
[01:28:52.946]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:52.946]                   NULL)
[01:28:52.946]                 if (is_error) {
[01:28:52.946]                   sessionInformation <- function() {
[01:28:52.946]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:52.946]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:52.946]                       search = base::search(), system = base::Sys.info())
[01:28:52.946]                   }
[01:28:52.946]                   ...future.conditions[[length(...future.conditions) + 
[01:28:52.946]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:52.946]                     cond$call), session = sessionInformation(), 
[01:28:52.946]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:52.946]                   signalCondition(cond)
[01:28:52.946]                 }
[01:28:52.946]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:52.946]                 "immediateCondition"))) {
[01:28:52.946]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:52.946]                   ...future.conditions[[length(...future.conditions) + 
[01:28:52.946]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:52.946]                   if (TRUE && !signal) {
[01:28:52.946]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:52.946]                     {
[01:28:52.946]                       inherits <- base::inherits
[01:28:52.946]                       invokeRestart <- base::invokeRestart
[01:28:52.946]                       is.null <- base::is.null
[01:28:52.946]                       muffled <- FALSE
[01:28:52.946]                       if (inherits(cond, "message")) {
[01:28:52.946]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:52.946]                         if (muffled) 
[01:28:52.946]                           invokeRestart("muffleMessage")
[01:28:52.946]                       }
[01:28:52.946]                       else if (inherits(cond, "warning")) {
[01:28:52.946]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:52.946]                         if (muffled) 
[01:28:52.946]                           invokeRestart("muffleWarning")
[01:28:52.946]                       }
[01:28:52.946]                       else if (inherits(cond, "condition")) {
[01:28:52.946]                         if (!is.null(pattern)) {
[01:28:52.946]                           computeRestarts <- base::computeRestarts
[01:28:52.946]                           grepl <- base::grepl
[01:28:52.946]                           restarts <- computeRestarts(cond)
[01:28:52.946]                           for (restart in restarts) {
[01:28:52.946]                             name <- restart$name
[01:28:52.946]                             if (is.null(name)) 
[01:28:52.946]                               next
[01:28:52.946]                             if (!grepl(pattern, name)) 
[01:28:52.946]                               next
[01:28:52.946]                             invokeRestart(restart)
[01:28:52.946]                             muffled <- TRUE
[01:28:52.946]                             break
[01:28:52.946]                           }
[01:28:52.946]                         }
[01:28:52.946]                       }
[01:28:52.946]                       invisible(muffled)
[01:28:52.946]                     }
[01:28:52.946]                     muffleCondition(cond, pattern = "^muffle")
[01:28:52.946]                   }
[01:28:52.946]                 }
[01:28:52.946]                 else {
[01:28:52.946]                   if (TRUE) {
[01:28:52.946]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:52.946]                     {
[01:28:52.946]                       inherits <- base::inherits
[01:28:52.946]                       invokeRestart <- base::invokeRestart
[01:28:52.946]                       is.null <- base::is.null
[01:28:52.946]                       muffled <- FALSE
[01:28:52.946]                       if (inherits(cond, "message")) {
[01:28:52.946]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:52.946]                         if (muffled) 
[01:28:52.946]                           invokeRestart("muffleMessage")
[01:28:52.946]                       }
[01:28:52.946]                       else if (inherits(cond, "warning")) {
[01:28:52.946]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:52.946]                         if (muffled) 
[01:28:52.946]                           invokeRestart("muffleWarning")
[01:28:52.946]                       }
[01:28:52.946]                       else if (inherits(cond, "condition")) {
[01:28:52.946]                         if (!is.null(pattern)) {
[01:28:52.946]                           computeRestarts <- base::computeRestarts
[01:28:52.946]                           grepl <- base::grepl
[01:28:52.946]                           restarts <- computeRestarts(cond)
[01:28:52.946]                           for (restart in restarts) {
[01:28:52.946]                             name <- restart$name
[01:28:52.946]                             if (is.null(name)) 
[01:28:52.946]                               next
[01:28:52.946]                             if (!grepl(pattern, name)) 
[01:28:52.946]                               next
[01:28:52.946]                             invokeRestart(restart)
[01:28:52.946]                             muffled <- TRUE
[01:28:52.946]                             break
[01:28:52.946]                           }
[01:28:52.946]                         }
[01:28:52.946]                       }
[01:28:52.946]                       invisible(muffled)
[01:28:52.946]                     }
[01:28:52.946]                     muffleCondition(cond, pattern = "^muffle")
[01:28:52.946]                   }
[01:28:52.946]                 }
[01:28:52.946]             }
[01:28:52.946]         }))
[01:28:52.946]     }, error = function(ex) {
[01:28:52.946]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:52.946]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:52.946]                 ...future.rng), started = ...future.startTime, 
[01:28:52.946]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:52.946]             version = "1.8"), class = "FutureResult")
[01:28:52.946]     }, finally = {
[01:28:52.946]         if (!identical(...future.workdir, getwd())) 
[01:28:52.946]             setwd(...future.workdir)
[01:28:52.946]         {
[01:28:52.946]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:52.946]                 ...future.oldOptions$nwarnings <- NULL
[01:28:52.946]             }
[01:28:52.946]             base::options(...future.oldOptions)
[01:28:52.946]             if (.Platform$OS.type == "windows") {
[01:28:52.946]                 old_names <- names(...future.oldEnvVars)
[01:28:52.946]                 envs <- base::Sys.getenv()
[01:28:52.946]                 names <- names(envs)
[01:28:52.946]                 common <- intersect(names, old_names)
[01:28:52.946]                 added <- setdiff(names, old_names)
[01:28:52.946]                 removed <- setdiff(old_names, names)
[01:28:52.946]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:52.946]                   envs[common]]
[01:28:52.946]                 NAMES <- toupper(changed)
[01:28:52.946]                 args <- list()
[01:28:52.946]                 for (kk in seq_along(NAMES)) {
[01:28:52.946]                   name <- changed[[kk]]
[01:28:52.946]                   NAME <- NAMES[[kk]]
[01:28:52.946]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:52.946]                     next
[01:28:52.946]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:52.946]                 }
[01:28:52.946]                 NAMES <- toupper(added)
[01:28:52.946]                 for (kk in seq_along(NAMES)) {
[01:28:52.946]                   name <- added[[kk]]
[01:28:52.946]                   NAME <- NAMES[[kk]]
[01:28:52.946]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:52.946]                     next
[01:28:52.946]                   args[[name]] <- ""
[01:28:52.946]                 }
[01:28:52.946]                 NAMES <- toupper(removed)
[01:28:52.946]                 for (kk in seq_along(NAMES)) {
[01:28:52.946]                   name <- removed[[kk]]
[01:28:52.946]                   NAME <- NAMES[[kk]]
[01:28:52.946]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:52.946]                     next
[01:28:52.946]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:52.946]                 }
[01:28:52.946]                 if (length(args) > 0) 
[01:28:52.946]                   base::do.call(base::Sys.setenv, args = args)
[01:28:52.946]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:52.946]             }
[01:28:52.946]             else {
[01:28:52.946]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:52.946]             }
[01:28:52.946]             {
[01:28:52.946]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:52.946]                   0L) {
[01:28:52.946]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:52.946]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:52.946]                   base::options(opts)
[01:28:52.946]                 }
[01:28:52.946]                 {
[01:28:52.946]                   {
[01:28:52.946]                     NULL
[01:28:52.946]                     RNGkind("Mersenne-Twister")
[01:28:52.946]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:52.946]                       inherits = FALSE)
[01:28:52.946]                   }
[01:28:52.946]                   options(future.plan = NULL)
[01:28:52.946]                   if (is.na(NA_character_)) 
[01:28:52.946]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:52.946]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:52.946]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:52.946]                   {
[01:28:52.946]                     future <- SequentialFuture(..., envir = envir)
[01:28:52.946]                     if (!future$lazy) 
[01:28:52.946]                       future <- run(future)
[01:28:52.946]                     invisible(future)
[01:28:52.946]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:52.946]                 }
[01:28:52.946]             }
[01:28:52.946]         }
[01:28:52.946]     })
[01:28:52.946]     if (TRUE) {
[01:28:52.946]         base::sink(type = "output", split = FALSE)
[01:28:52.946]         if (TRUE) {
[01:28:52.946]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:52.946]         }
[01:28:52.946]         else {
[01:28:52.946]             ...future.result["stdout"] <- base::list(NULL)
[01:28:52.946]         }
[01:28:52.946]         base::close(...future.stdout)
[01:28:52.946]         ...future.stdout <- NULL
[01:28:52.946]     }
[01:28:52.946]     ...future.result$conditions <- ...future.conditions
[01:28:52.946]     ...future.result$finished <- base::Sys.time()
[01:28:52.946]     ...future.result
[01:28:52.946] }
[01:28:52.951] plan(): Setting new future strategy stack:
[01:28:52.951] List of future strategies:
[01:28:52.951] 1. sequential:
[01:28:52.951]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:52.951]    - tweaked: FALSE
[01:28:52.951]    - call: NULL
[01:28:52.953] plan(): nbrOfWorkers() = 1
[01:28:52.955] plan(): Setting new future strategy stack:
[01:28:52.956] List of future strategies:
[01:28:52.956] 1. sequential:
[01:28:52.956]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:52.956]    - tweaked: FALSE
[01:28:52.956]    - call: plan(strategy)
[01:28:52.956] plan(): nbrOfWorkers() = 1
[01:28:52.957] SequentialFuture started (and completed)
[01:28:52.957] - Launch lazy future ... done
[01:28:52.957] run() for 'SequentialFuture' ... done
[01:28:52.958] resolved() for 'SequentialFuture' ...
[01:28:52.961] - state: 'finished'
[01:28:52.961] - run: TRUE
[01:28:52.962] - result: 'FutureResult'
[01:28:52.962] resolved() for 'SequentialFuture' ... done
[01:28:52.962] Future #2
[01:28:52.962]  length: 1 (resolved future 2)
[01:28:52.963]  length: 0 (resolved future 3)
[01:28:52.963] resolve() on list ... DONE
[01:28:52.963] resolved() for 'SequentialFuture' ...
[01:28:52.963] - state: 'finished'
[01:28:52.963] - run: TRUE
[01:28:52.964] - result: 'FutureResult'
[01:28:52.964] resolved() for 'SequentialFuture' ... done
[01:28:52.964] resolved() for 'SequentialFuture' ...
[01:28:52.964] - state: 'finished'
[01:28:52.965] - run: TRUE
[01:28:52.965] - result: 'FutureResult'
[01:28:52.965] resolved() for 'SequentialFuture' ... done
[01:28:52.965] getGlobalsAndPackages() ...
[01:28:52.965] Searching for globals...
[01:28:52.966] 
[01:28:52.966] Searching for globals ... DONE
[01:28:52.966] - globals: [0] <none>
[01:28:52.967] getGlobalsAndPackages() ... DONE
[01:28:52.967] run() for 'Future' ...
[01:28:52.967] - state: 'created'
[01:28:52.968] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:52.968] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:52.968] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:52.969]   - Field: 'label'
[01:28:52.969]   - Field: 'local'
[01:28:52.969]   - Field: 'owner'
[01:28:52.969]   - Field: 'envir'
[01:28:52.969]   - Field: 'packages'
[01:28:52.970]   - Field: 'gc'
[01:28:52.970]   - Field: 'conditions'
[01:28:52.970]   - Field: 'expr'
[01:28:52.970]   - Field: 'uuid'
[01:28:52.970]   - Field: 'seed'
[01:28:52.971]   - Field: 'version'
[01:28:52.971]   - Field: 'result'
[01:28:52.971]   - Field: 'asynchronous'
[01:28:52.971]   - Field: 'calls'
[01:28:52.971]   - Field: 'globals'
[01:28:52.972]   - Field: 'stdout'
[01:28:52.972]   - Field: 'earlySignal'
[01:28:52.972]   - Field: 'lazy'
[01:28:52.972]   - Field: 'state'
[01:28:52.972] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:52.973] - Launch lazy future ...
[01:28:52.973] Packages needed by the future expression (n = 0): <none>
[01:28:52.973] Packages needed by future strategies (n = 0): <none>
[01:28:52.974] {
[01:28:52.974]     {
[01:28:52.974]         {
[01:28:52.974]             ...future.startTime <- base::Sys.time()
[01:28:52.974]             {
[01:28:52.974]                 {
[01:28:52.974]                   {
[01:28:52.974]                     base::local({
[01:28:52.974]                       has_future <- base::requireNamespace("future", 
[01:28:52.974]                         quietly = TRUE)
[01:28:52.974]                       if (has_future) {
[01:28:52.974]                         ns <- base::getNamespace("future")
[01:28:52.974]                         version <- ns[[".package"]][["version"]]
[01:28:52.974]                         if (is.null(version)) 
[01:28:52.974]                           version <- utils::packageVersion("future")
[01:28:52.974]                       }
[01:28:52.974]                       else {
[01:28:52.974]                         version <- NULL
[01:28:52.974]                       }
[01:28:52.974]                       if (!has_future || version < "1.8.0") {
[01:28:52.974]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:52.974]                           "", base::R.version$version.string), 
[01:28:52.974]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:52.974]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:52.974]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:52.974]                             "release", "version")], collapse = " "), 
[01:28:52.974]                           hostname = base::Sys.info()[["nodename"]])
[01:28:52.974]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:52.974]                           info)
[01:28:52.974]                         info <- base::paste(info, collapse = "; ")
[01:28:52.974]                         if (!has_future) {
[01:28:52.974]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:52.974]                             info)
[01:28:52.974]                         }
[01:28:52.974]                         else {
[01:28:52.974]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:52.974]                             info, version)
[01:28:52.974]                         }
[01:28:52.974]                         base::stop(msg)
[01:28:52.974]                       }
[01:28:52.974]                     })
[01:28:52.974]                   }
[01:28:52.974]                   options(future.plan = NULL)
[01:28:52.974]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:52.974]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:52.974]                 }
[01:28:52.974]                 ...future.workdir <- getwd()
[01:28:52.974]             }
[01:28:52.974]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:52.974]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:52.974]         }
[01:28:52.974]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:52.974]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:52.974]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:52.974]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:52.974]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:52.974]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:52.974]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:52.974]             base::names(...future.oldOptions))
[01:28:52.974]     }
[01:28:52.974]     if (FALSE) {
[01:28:52.974]     }
[01:28:52.974]     else {
[01:28:52.974]         if (TRUE) {
[01:28:52.974]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:52.974]                 open = "w")
[01:28:52.974]         }
[01:28:52.974]         else {
[01:28:52.974]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:52.974]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:52.974]         }
[01:28:52.974]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:52.974]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:52.974]             base::sink(type = "output", split = FALSE)
[01:28:52.974]             base::close(...future.stdout)
[01:28:52.974]         }, add = TRUE)
[01:28:52.974]     }
[01:28:52.974]     ...future.frame <- base::sys.nframe()
[01:28:52.974]     ...future.conditions <- base::list()
[01:28:52.974]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:52.974]     if (FALSE) {
[01:28:52.974]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:52.974]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:52.974]     }
[01:28:52.974]     ...future.result <- base::tryCatch({
[01:28:52.974]         base::withCallingHandlers({
[01:28:52.974]             ...future.value <- base::withVisible(base::local(1))
[01:28:52.974]             future::FutureResult(value = ...future.value$value, 
[01:28:52.974]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:52.974]                   ...future.rng), globalenv = if (FALSE) 
[01:28:52.974]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:52.974]                     ...future.globalenv.names))
[01:28:52.974]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:52.974]         }, condition = base::local({
[01:28:52.974]             c <- base::c
[01:28:52.974]             inherits <- base::inherits
[01:28:52.974]             invokeRestart <- base::invokeRestart
[01:28:52.974]             length <- base::length
[01:28:52.974]             list <- base::list
[01:28:52.974]             seq.int <- base::seq.int
[01:28:52.974]             signalCondition <- base::signalCondition
[01:28:52.974]             sys.calls <- base::sys.calls
[01:28:52.974]             `[[` <- base::`[[`
[01:28:52.974]             `+` <- base::`+`
[01:28:52.974]             `<<-` <- base::`<<-`
[01:28:52.974]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:52.974]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:52.974]                   3L)]
[01:28:52.974]             }
[01:28:52.974]             function(cond) {
[01:28:52.974]                 is_error <- inherits(cond, "error")
[01:28:52.974]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:52.974]                   NULL)
[01:28:52.974]                 if (is_error) {
[01:28:52.974]                   sessionInformation <- function() {
[01:28:52.974]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:52.974]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:52.974]                       search = base::search(), system = base::Sys.info())
[01:28:52.974]                   }
[01:28:52.974]                   ...future.conditions[[length(...future.conditions) + 
[01:28:52.974]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:52.974]                     cond$call), session = sessionInformation(), 
[01:28:52.974]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:52.974]                   signalCondition(cond)
[01:28:52.974]                 }
[01:28:52.974]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:52.974]                 "immediateCondition"))) {
[01:28:52.974]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:52.974]                   ...future.conditions[[length(...future.conditions) + 
[01:28:52.974]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:52.974]                   if (TRUE && !signal) {
[01:28:52.974]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:52.974]                     {
[01:28:52.974]                       inherits <- base::inherits
[01:28:52.974]                       invokeRestart <- base::invokeRestart
[01:28:52.974]                       is.null <- base::is.null
[01:28:52.974]                       muffled <- FALSE
[01:28:52.974]                       if (inherits(cond, "message")) {
[01:28:52.974]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:52.974]                         if (muffled) 
[01:28:52.974]                           invokeRestart("muffleMessage")
[01:28:52.974]                       }
[01:28:52.974]                       else if (inherits(cond, "warning")) {
[01:28:52.974]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:52.974]                         if (muffled) 
[01:28:52.974]                           invokeRestart("muffleWarning")
[01:28:52.974]                       }
[01:28:52.974]                       else if (inherits(cond, "condition")) {
[01:28:52.974]                         if (!is.null(pattern)) {
[01:28:52.974]                           computeRestarts <- base::computeRestarts
[01:28:52.974]                           grepl <- base::grepl
[01:28:52.974]                           restarts <- computeRestarts(cond)
[01:28:52.974]                           for (restart in restarts) {
[01:28:52.974]                             name <- restart$name
[01:28:52.974]                             if (is.null(name)) 
[01:28:52.974]                               next
[01:28:52.974]                             if (!grepl(pattern, name)) 
[01:28:52.974]                               next
[01:28:52.974]                             invokeRestart(restart)
[01:28:52.974]                             muffled <- TRUE
[01:28:52.974]                             break
[01:28:52.974]                           }
[01:28:52.974]                         }
[01:28:52.974]                       }
[01:28:52.974]                       invisible(muffled)
[01:28:52.974]                     }
[01:28:52.974]                     muffleCondition(cond, pattern = "^muffle")
[01:28:52.974]                   }
[01:28:52.974]                 }
[01:28:52.974]                 else {
[01:28:52.974]                   if (TRUE) {
[01:28:52.974]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:52.974]                     {
[01:28:52.974]                       inherits <- base::inherits
[01:28:52.974]                       invokeRestart <- base::invokeRestart
[01:28:52.974]                       is.null <- base::is.null
[01:28:52.974]                       muffled <- FALSE
[01:28:52.974]                       if (inherits(cond, "message")) {
[01:28:52.974]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:52.974]                         if (muffled) 
[01:28:52.974]                           invokeRestart("muffleMessage")
[01:28:52.974]                       }
[01:28:52.974]                       else if (inherits(cond, "warning")) {
[01:28:52.974]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:52.974]                         if (muffled) 
[01:28:52.974]                           invokeRestart("muffleWarning")
[01:28:52.974]                       }
[01:28:52.974]                       else if (inherits(cond, "condition")) {
[01:28:52.974]                         if (!is.null(pattern)) {
[01:28:52.974]                           computeRestarts <- base::computeRestarts
[01:28:52.974]                           grepl <- base::grepl
[01:28:52.974]                           restarts <- computeRestarts(cond)
[01:28:52.974]                           for (restart in restarts) {
[01:28:52.974]                             name <- restart$name
[01:28:52.974]                             if (is.null(name)) 
[01:28:52.974]                               next
[01:28:52.974]                             if (!grepl(pattern, name)) 
[01:28:52.974]                               next
[01:28:52.974]                             invokeRestart(restart)
[01:28:52.974]                             muffled <- TRUE
[01:28:52.974]                             break
[01:28:52.974]                           }
[01:28:52.974]                         }
[01:28:52.974]                       }
[01:28:52.974]                       invisible(muffled)
[01:28:52.974]                     }
[01:28:52.974]                     muffleCondition(cond, pattern = "^muffle")
[01:28:52.974]                   }
[01:28:52.974]                 }
[01:28:52.974]             }
[01:28:52.974]         }))
[01:28:52.974]     }, error = function(ex) {
[01:28:52.974]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:52.974]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:52.974]                 ...future.rng), started = ...future.startTime, 
[01:28:52.974]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:52.974]             version = "1.8"), class = "FutureResult")
[01:28:52.974]     }, finally = {
[01:28:52.974]         if (!identical(...future.workdir, getwd())) 
[01:28:52.974]             setwd(...future.workdir)
[01:28:52.974]         {
[01:28:52.974]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:52.974]                 ...future.oldOptions$nwarnings <- NULL
[01:28:52.974]             }
[01:28:52.974]             base::options(...future.oldOptions)
[01:28:52.974]             if (.Platform$OS.type == "windows") {
[01:28:52.974]                 old_names <- names(...future.oldEnvVars)
[01:28:52.974]                 envs <- base::Sys.getenv()
[01:28:52.974]                 names <- names(envs)
[01:28:52.974]                 common <- intersect(names, old_names)
[01:28:52.974]                 added <- setdiff(names, old_names)
[01:28:52.974]                 removed <- setdiff(old_names, names)
[01:28:52.974]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:52.974]                   envs[common]]
[01:28:52.974]                 NAMES <- toupper(changed)
[01:28:52.974]                 args <- list()
[01:28:52.974]                 for (kk in seq_along(NAMES)) {
[01:28:52.974]                   name <- changed[[kk]]
[01:28:52.974]                   NAME <- NAMES[[kk]]
[01:28:52.974]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:52.974]                     next
[01:28:52.974]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:52.974]                 }
[01:28:52.974]                 NAMES <- toupper(added)
[01:28:52.974]                 for (kk in seq_along(NAMES)) {
[01:28:52.974]                   name <- added[[kk]]
[01:28:52.974]                   NAME <- NAMES[[kk]]
[01:28:52.974]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:52.974]                     next
[01:28:52.974]                   args[[name]] <- ""
[01:28:52.974]                 }
[01:28:52.974]                 NAMES <- toupper(removed)
[01:28:52.974]                 for (kk in seq_along(NAMES)) {
[01:28:52.974]                   name <- removed[[kk]]
[01:28:52.974]                   NAME <- NAMES[[kk]]
[01:28:52.974]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:52.974]                     next
[01:28:52.974]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:52.974]                 }
[01:28:52.974]                 if (length(args) > 0) 
[01:28:52.974]                   base::do.call(base::Sys.setenv, args = args)
[01:28:52.974]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:52.974]             }
[01:28:52.974]             else {
[01:28:52.974]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:52.974]             }
[01:28:52.974]             {
[01:28:52.974]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:52.974]                   0L) {
[01:28:52.974]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:52.974]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:52.974]                   base::options(opts)
[01:28:52.974]                 }
[01:28:52.974]                 {
[01:28:52.974]                   {
[01:28:52.974]                     NULL
[01:28:52.974]                     RNGkind("Mersenne-Twister")
[01:28:52.974]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:52.974]                       inherits = FALSE)
[01:28:52.974]                   }
[01:28:52.974]                   options(future.plan = NULL)
[01:28:52.974]                   if (is.na(NA_character_)) 
[01:28:52.974]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:52.974]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:52.974]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:52.974]                   {
[01:28:52.974]                     future <- SequentialFuture(..., envir = envir)
[01:28:52.974]                     if (!future$lazy) 
[01:28:52.974]                       future <- run(future)
[01:28:52.974]                     invisible(future)
[01:28:52.974]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:52.974]                 }
[01:28:52.974]             }
[01:28:52.974]         }
[01:28:52.974]     })
[01:28:52.974]     if (TRUE) {
[01:28:52.974]         base::sink(type = "output", split = FALSE)
[01:28:52.974]         if (TRUE) {
[01:28:52.974]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:52.974]         }
[01:28:52.974]         else {
[01:28:52.974]             ...future.result["stdout"] <- base::list(NULL)
[01:28:52.974]         }
[01:28:52.974]         base::close(...future.stdout)
[01:28:52.974]         ...future.stdout <- NULL
[01:28:52.974]     }
[01:28:52.974]     ...future.result$conditions <- ...future.conditions
[01:28:52.974]     ...future.result$finished <- base::Sys.time()
[01:28:52.974]     ...future.result
[01:28:52.974] }
[01:28:52.978] plan(): Setting new future strategy stack:
[01:28:52.978] List of future strategies:
[01:28:52.978] 1. sequential:
[01:28:52.978]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:52.978]    - tweaked: FALSE
[01:28:52.978]    - call: NULL
[01:28:52.979] plan(): nbrOfWorkers() = 1
[01:28:52.981] plan(): Setting new future strategy stack:
[01:28:52.981] List of future strategies:
[01:28:52.981] 1. sequential:
[01:28:52.981]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:52.981]    - tweaked: FALSE
[01:28:52.981]    - call: plan(strategy)
[01:28:52.981] plan(): nbrOfWorkers() = 1
[01:28:52.982] SequentialFuture started (and completed)
[01:28:52.982] - Launch lazy future ... done
[01:28:52.982] run() for 'SequentialFuture' ... done
[01:28:52.982] getGlobalsAndPackages() ...
[01:28:52.983] Searching for globals...
[01:28:52.990] - globals found: [2] '{', 'Sys.sleep'
[01:28:52.990] Searching for globals ... DONE
[01:28:52.990] Resolving globals: FALSE
[01:28:52.991] 
[01:28:52.991] 
[01:28:52.992] getGlobalsAndPackages() ... DONE
[01:28:52.992] run() for 'Future' ...
[01:28:52.992] - state: 'created'
[01:28:52.992] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:52.993] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:52.993] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:52.993]   - Field: 'label'
[01:28:52.993]   - Field: 'local'
[01:28:52.994]   - Field: 'owner'
[01:28:52.994]   - Field: 'envir'
[01:28:52.994]   - Field: 'packages'
[01:28:52.994]   - Field: 'gc'
[01:28:52.994]   - Field: 'conditions'
[01:28:52.995]   - Field: 'expr'
[01:28:52.995]   - Field: 'uuid'
[01:28:52.995]   - Field: 'seed'
[01:28:52.995]   - Field: 'version'
[01:28:52.995]   - Field: 'result'
[01:28:52.996]   - Field: 'asynchronous'
[01:28:52.996]   - Field: 'calls'
[01:28:52.996]   - Field: 'globals'
[01:28:52.996]   - Field: 'stdout'
[01:28:52.996]   - Field: 'earlySignal'
[01:28:52.997]   - Field: 'lazy'
[01:28:52.997]   - Field: 'state'
[01:28:52.997] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:52.997] - Launch lazy future ...
[01:28:52.998] Packages needed by the future expression (n = 0): <none>
[01:28:52.998] Packages needed by future strategies (n = 0): <none>
[01:28:52.998] {
[01:28:52.998]     {
[01:28:52.998]         {
[01:28:52.998]             ...future.startTime <- base::Sys.time()
[01:28:52.998]             {
[01:28:52.998]                 {
[01:28:52.998]                   {
[01:28:52.998]                     base::local({
[01:28:52.998]                       has_future <- base::requireNamespace("future", 
[01:28:52.998]                         quietly = TRUE)
[01:28:52.998]                       if (has_future) {
[01:28:52.998]                         ns <- base::getNamespace("future")
[01:28:52.998]                         version <- ns[[".package"]][["version"]]
[01:28:52.998]                         if (is.null(version)) 
[01:28:52.998]                           version <- utils::packageVersion("future")
[01:28:52.998]                       }
[01:28:52.998]                       else {
[01:28:52.998]                         version <- NULL
[01:28:52.998]                       }
[01:28:52.998]                       if (!has_future || version < "1.8.0") {
[01:28:52.998]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:52.998]                           "", base::R.version$version.string), 
[01:28:52.998]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:52.998]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:52.998]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:52.998]                             "release", "version")], collapse = " "), 
[01:28:52.998]                           hostname = base::Sys.info()[["nodename"]])
[01:28:52.998]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:52.998]                           info)
[01:28:52.998]                         info <- base::paste(info, collapse = "; ")
[01:28:52.998]                         if (!has_future) {
[01:28:52.998]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:52.998]                             info)
[01:28:52.998]                         }
[01:28:52.998]                         else {
[01:28:52.998]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:52.998]                             info, version)
[01:28:52.998]                         }
[01:28:52.998]                         base::stop(msg)
[01:28:52.998]                       }
[01:28:52.998]                     })
[01:28:52.998]                   }
[01:28:52.998]                   options(future.plan = NULL)
[01:28:52.998]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:52.998]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:52.998]                 }
[01:28:52.998]                 ...future.workdir <- getwd()
[01:28:52.998]             }
[01:28:52.998]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:52.998]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:52.998]         }
[01:28:52.998]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:52.998]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:52.998]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:52.998]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:52.998]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:52.998]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:52.998]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:52.998]             base::names(...future.oldOptions))
[01:28:52.998]     }
[01:28:52.998]     if (FALSE) {
[01:28:52.998]     }
[01:28:52.998]     else {
[01:28:52.998]         if (TRUE) {
[01:28:52.998]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:52.998]                 open = "w")
[01:28:52.998]         }
[01:28:52.998]         else {
[01:28:52.998]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:52.998]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:52.998]         }
[01:28:52.998]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:52.998]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:52.998]             base::sink(type = "output", split = FALSE)
[01:28:52.998]             base::close(...future.stdout)
[01:28:52.998]         }, add = TRUE)
[01:28:52.998]     }
[01:28:52.998]     ...future.frame <- base::sys.nframe()
[01:28:52.998]     ...future.conditions <- base::list()
[01:28:52.998]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:52.998]     if (FALSE) {
[01:28:52.998]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:52.998]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:52.998]     }
[01:28:52.998]     ...future.result <- base::tryCatch({
[01:28:52.998]         base::withCallingHandlers({
[01:28:52.998]             ...future.value <- base::withVisible(base::local({
[01:28:52.998]                 Sys.sleep(0.5)
[01:28:52.998]                 2
[01:28:52.998]             }))
[01:28:52.998]             future::FutureResult(value = ...future.value$value, 
[01:28:52.998]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:52.998]                   ...future.rng), globalenv = if (FALSE) 
[01:28:52.998]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:52.998]                     ...future.globalenv.names))
[01:28:52.998]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:52.998]         }, condition = base::local({
[01:28:52.998]             c <- base::c
[01:28:52.998]             inherits <- base::inherits
[01:28:52.998]             invokeRestart <- base::invokeRestart
[01:28:52.998]             length <- base::length
[01:28:52.998]             list <- base::list
[01:28:52.998]             seq.int <- base::seq.int
[01:28:52.998]             signalCondition <- base::signalCondition
[01:28:52.998]             sys.calls <- base::sys.calls
[01:28:52.998]             `[[` <- base::`[[`
[01:28:52.998]             `+` <- base::`+`
[01:28:52.998]             `<<-` <- base::`<<-`
[01:28:52.998]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:52.998]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:52.998]                   3L)]
[01:28:52.998]             }
[01:28:52.998]             function(cond) {
[01:28:52.998]                 is_error <- inherits(cond, "error")
[01:28:52.998]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:52.998]                   NULL)
[01:28:52.998]                 if (is_error) {
[01:28:52.998]                   sessionInformation <- function() {
[01:28:52.998]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:52.998]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:52.998]                       search = base::search(), system = base::Sys.info())
[01:28:52.998]                   }
[01:28:52.998]                   ...future.conditions[[length(...future.conditions) + 
[01:28:52.998]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:52.998]                     cond$call), session = sessionInformation(), 
[01:28:52.998]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:52.998]                   signalCondition(cond)
[01:28:52.998]                 }
[01:28:52.998]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:52.998]                 "immediateCondition"))) {
[01:28:52.998]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:52.998]                   ...future.conditions[[length(...future.conditions) + 
[01:28:52.998]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:52.998]                   if (TRUE && !signal) {
[01:28:52.998]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:52.998]                     {
[01:28:52.998]                       inherits <- base::inherits
[01:28:52.998]                       invokeRestart <- base::invokeRestart
[01:28:52.998]                       is.null <- base::is.null
[01:28:52.998]                       muffled <- FALSE
[01:28:52.998]                       if (inherits(cond, "message")) {
[01:28:52.998]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:52.998]                         if (muffled) 
[01:28:52.998]                           invokeRestart("muffleMessage")
[01:28:52.998]                       }
[01:28:52.998]                       else if (inherits(cond, "warning")) {
[01:28:52.998]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:52.998]                         if (muffled) 
[01:28:52.998]                           invokeRestart("muffleWarning")
[01:28:52.998]                       }
[01:28:52.998]                       else if (inherits(cond, "condition")) {
[01:28:52.998]                         if (!is.null(pattern)) {
[01:28:52.998]                           computeRestarts <- base::computeRestarts
[01:28:52.998]                           grepl <- base::grepl
[01:28:52.998]                           restarts <- computeRestarts(cond)
[01:28:52.998]                           for (restart in restarts) {
[01:28:52.998]                             name <- restart$name
[01:28:52.998]                             if (is.null(name)) 
[01:28:52.998]                               next
[01:28:52.998]                             if (!grepl(pattern, name)) 
[01:28:52.998]                               next
[01:28:52.998]                             invokeRestart(restart)
[01:28:52.998]                             muffled <- TRUE
[01:28:52.998]                             break
[01:28:52.998]                           }
[01:28:52.998]                         }
[01:28:52.998]                       }
[01:28:52.998]                       invisible(muffled)
[01:28:52.998]                     }
[01:28:52.998]                     muffleCondition(cond, pattern = "^muffle")
[01:28:52.998]                   }
[01:28:52.998]                 }
[01:28:52.998]                 else {
[01:28:52.998]                   if (TRUE) {
[01:28:52.998]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:52.998]                     {
[01:28:52.998]                       inherits <- base::inherits
[01:28:52.998]                       invokeRestart <- base::invokeRestart
[01:28:52.998]                       is.null <- base::is.null
[01:28:52.998]                       muffled <- FALSE
[01:28:52.998]                       if (inherits(cond, "message")) {
[01:28:52.998]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:52.998]                         if (muffled) 
[01:28:52.998]                           invokeRestart("muffleMessage")
[01:28:52.998]                       }
[01:28:52.998]                       else if (inherits(cond, "warning")) {
[01:28:52.998]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:52.998]                         if (muffled) 
[01:28:52.998]                           invokeRestart("muffleWarning")
[01:28:52.998]                       }
[01:28:52.998]                       else if (inherits(cond, "condition")) {
[01:28:52.998]                         if (!is.null(pattern)) {
[01:28:52.998]                           computeRestarts <- base::computeRestarts
[01:28:52.998]                           grepl <- base::grepl
[01:28:52.998]                           restarts <- computeRestarts(cond)
[01:28:52.998]                           for (restart in restarts) {
[01:28:52.998]                             name <- restart$name
[01:28:52.998]                             if (is.null(name)) 
[01:28:52.998]                               next
[01:28:52.998]                             if (!grepl(pattern, name)) 
[01:28:52.998]                               next
[01:28:52.998]                             invokeRestart(restart)
[01:28:52.998]                             muffled <- TRUE
[01:28:52.998]                             break
[01:28:52.998]                           }
[01:28:52.998]                         }
[01:28:52.998]                       }
[01:28:52.998]                       invisible(muffled)
[01:28:52.998]                     }
[01:28:52.998]                     muffleCondition(cond, pattern = "^muffle")
[01:28:52.998]                   }
[01:28:52.998]                 }
[01:28:52.998]             }
[01:28:52.998]         }))
[01:28:52.998]     }, error = function(ex) {
[01:28:52.998]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:52.998]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:52.998]                 ...future.rng), started = ...future.startTime, 
[01:28:52.998]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:52.998]             version = "1.8"), class = "FutureResult")
[01:28:52.998]     }, finally = {
[01:28:52.998]         if (!identical(...future.workdir, getwd())) 
[01:28:52.998]             setwd(...future.workdir)
[01:28:52.998]         {
[01:28:52.998]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:52.998]                 ...future.oldOptions$nwarnings <- NULL
[01:28:52.998]             }
[01:28:52.998]             base::options(...future.oldOptions)
[01:28:52.998]             if (.Platform$OS.type == "windows") {
[01:28:52.998]                 old_names <- names(...future.oldEnvVars)
[01:28:52.998]                 envs <- base::Sys.getenv()
[01:28:52.998]                 names <- names(envs)
[01:28:52.998]                 common <- intersect(names, old_names)
[01:28:52.998]                 added <- setdiff(names, old_names)
[01:28:52.998]                 removed <- setdiff(old_names, names)
[01:28:52.998]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:52.998]                   envs[common]]
[01:28:52.998]                 NAMES <- toupper(changed)
[01:28:52.998]                 args <- list()
[01:28:52.998]                 for (kk in seq_along(NAMES)) {
[01:28:52.998]                   name <- changed[[kk]]
[01:28:52.998]                   NAME <- NAMES[[kk]]
[01:28:52.998]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:52.998]                     next
[01:28:52.998]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:52.998]                 }
[01:28:52.998]                 NAMES <- toupper(added)
[01:28:52.998]                 for (kk in seq_along(NAMES)) {
[01:28:52.998]                   name <- added[[kk]]
[01:28:52.998]                   NAME <- NAMES[[kk]]
[01:28:52.998]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:52.998]                     next
[01:28:52.998]                   args[[name]] <- ""
[01:28:52.998]                 }
[01:28:52.998]                 NAMES <- toupper(removed)
[01:28:52.998]                 for (kk in seq_along(NAMES)) {
[01:28:52.998]                   name <- removed[[kk]]
[01:28:52.998]                   NAME <- NAMES[[kk]]
[01:28:52.998]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:52.998]                     next
[01:28:52.998]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:52.998]                 }
[01:28:52.998]                 if (length(args) > 0) 
[01:28:52.998]                   base::do.call(base::Sys.setenv, args = args)
[01:28:52.998]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:52.998]             }
[01:28:52.998]             else {
[01:28:52.998]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:52.998]             }
[01:28:52.998]             {
[01:28:52.998]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:52.998]                   0L) {
[01:28:52.998]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:52.998]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:52.998]                   base::options(opts)
[01:28:52.998]                 }
[01:28:52.998]                 {
[01:28:52.998]                   {
[01:28:52.998]                     NULL
[01:28:52.998]                     RNGkind("Mersenne-Twister")
[01:28:52.998]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:52.998]                       inherits = FALSE)
[01:28:52.998]                   }
[01:28:52.998]                   options(future.plan = NULL)
[01:28:52.998]                   if (is.na(NA_character_)) 
[01:28:52.998]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:52.998]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:52.998]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:52.998]                   {
[01:28:52.998]                     future <- SequentialFuture(..., envir = envir)
[01:28:52.998]                     if (!future$lazy) 
[01:28:52.998]                       future <- run(future)
[01:28:52.998]                     invisible(future)
[01:28:52.998]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:52.998]                 }
[01:28:52.998]             }
[01:28:52.998]         }
[01:28:52.998]     })
[01:28:52.998]     if (TRUE) {
[01:28:52.998]         base::sink(type = "output", split = FALSE)
[01:28:52.998]         if (TRUE) {
[01:28:52.998]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:52.998]         }
[01:28:52.998]         else {
[01:28:52.998]             ...future.result["stdout"] <- base::list(NULL)
[01:28:52.998]         }
[01:28:52.998]         base::close(...future.stdout)
[01:28:52.998]         ...future.stdout <- NULL
[01:28:52.998]     }
[01:28:52.998]     ...future.result$conditions <- ...future.conditions
[01:28:52.998]     ...future.result$finished <- base::Sys.time()
[01:28:52.998]     ...future.result
[01:28:52.998] }
[01:28:53.003] plan(): Setting new future strategy stack:
[01:28:53.003] List of future strategies:
[01:28:53.003] 1. sequential:
[01:28:53.003]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:53.003]    - tweaked: FALSE
[01:28:53.003]    - call: NULL
[01:28:53.004] plan(): nbrOfWorkers() = 1
[01:28:53.515] plan(): Setting new future strategy stack:
[01:28:53.516] List of future strategies:
[01:28:53.516] 1. sequential:
[01:28:53.516]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:53.516]    - tweaked: FALSE
[01:28:53.516]    - call: plan(strategy)
[01:28:53.517] plan(): nbrOfWorkers() = 1
[01:28:53.517] SequentialFuture started (and completed)
[01:28:53.517] - Launch lazy future ... done
[01:28:53.517] run() for 'SequentialFuture' ... done
[01:28:53.518] resolve() on list ...
[01:28:53.518]  recursive: 0
[01:28:53.519]  length: 1
[01:28:53.519] 
[01:28:53.519] resolved() for 'SequentialFuture' ...
[01:28:53.519] - state: 'finished'
[01:28:53.519] - run: TRUE
[01:28:53.519] - result: 'FutureResult'
[01:28:53.520] resolved() for 'SequentialFuture' ... done
[01:28:53.520] Future #1
[01:28:53.520]  length: 0 (resolved future 1)
[01:28:53.520] resolve() on list ... DONE
[01:28:53.520] resolved() for 'SequentialFuture' ...
[01:28:53.521] - state: 'finished'
[01:28:53.521] - run: TRUE
[01:28:53.521] - result: 'FutureResult'
[01:28:53.521] resolved() for 'SequentialFuture' ... done
[01:28:53.522] resolve() on list ...
[01:28:53.522]  recursive: 0
[01:28:53.522]  length: 1
[01:28:53.525] 
[01:28:53.526] resolved() for 'SequentialFuture' ...
[01:28:53.526] - state: 'finished'
[01:28:53.526] - run: TRUE
[01:28:53.526] - result: 'FutureResult'
[01:28:53.526] resolved() for 'SequentialFuture' ... done
[01:28:53.527] Future #1
[01:28:53.527]  length: 0 (resolved future 1)
[01:28:53.527] resolve() on list ... DONE
[01:28:53.527] resolved() for 'SequentialFuture' ...
[01:28:53.527] - state: 'finished'
[01:28:53.528] - run: TRUE
[01:28:53.528] - result: 'FutureResult'
[01:28:53.528] resolved() for 'SequentialFuture' ... done
[01:28:53.528] resolve() on list ...
[01:28:53.528]  recursive: 0
[01:28:53.529]  length: 1
[01:28:53.529] 
[01:28:53.529]  length: 0 (resolved future 1)
[01:28:53.529] resolve() on list ... DONE
[01:28:53.529] resolve() on list ...
[01:28:53.530]  recursive: 0
[01:28:53.530]  length: 4
[01:28:53.530] 
[01:28:53.530] resolved() for 'SequentialFuture' ...
[01:28:53.530] - state: 'finished'
[01:28:53.531] - run: TRUE
[01:28:53.531] - result: 'FutureResult'
[01:28:53.531] resolved() for 'SequentialFuture' ... done
[01:28:53.531] Future #1
[01:28:53.531]  length: 3 (resolved future 1)
[01:28:53.531] resolved() for 'SequentialFuture' ...
[01:28:53.532] - state: 'finished'
[01:28:53.532] - run: TRUE
[01:28:53.532] - result: 'FutureResult'
[01:28:53.532] resolved() for 'SequentialFuture' ... done
[01:28:53.532] Future #2
[01:28:53.533]  length: 2 (resolved future 2)
[01:28:53.533]  length: 1 (resolved future 3)
[01:28:53.533]  length: 0 (resolved future 4)
[01:28:53.533] resolve() on list ... DONE
[01:28:53.533] resolve() on list ...
[01:28:53.534]  recursive: 0
[01:28:53.534]  length: 4
[01:28:53.534] 
[01:28:53.534] resolved() for 'SequentialFuture' ...
[01:28:53.534] - state: 'finished'
[01:28:53.535] - run: TRUE
[01:28:53.535] - result: 'FutureResult'
[01:28:53.535] resolved() for 'SequentialFuture' ... done
[01:28:53.535] Future #1
[01:28:53.535]  length: 3 (resolved future 1)
[01:28:53.535] resolved() for 'SequentialFuture' ...
[01:28:53.536] - state: 'finished'
[01:28:53.536] - run: TRUE
[01:28:53.536] - result: 'FutureResult'
[01:28:53.536] resolved() for 'SequentialFuture' ... done
[01:28:53.536] Future #2
[01:28:53.537]  length: 2 (resolved future 2)
[01:28:53.537]  length: 1 (resolved future 3)
[01:28:53.537]  length: 0 (resolved future 4)
[01:28:53.537] resolve() on list ... DONE
[01:28:53.538] resolve() on list ...
[01:28:53.538]  recursive: 0
[01:28:53.538]  length: 1
[01:28:53.538] 
[01:28:53.538]  length: 0 (resolved future 1)
[01:28:53.539] resolve() on list ... DONE
[01:28:53.539] getGlobalsAndPackages() ...
[01:28:53.539] Searching for globals...
[01:28:53.540] - globals found: [3] '{', 'Sys.sleep', 'kk'
[01:28:53.541] Searching for globals ... DONE
[01:28:53.541] Resolving globals: FALSE
[01:28:53.542] The total size of the 1 globals is 56 bytes (56 bytes)
[01:28:53.543] The total size of the 1 globals exported for future expression ('{; Sys.sleep(0.1); kk; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'kk' (56 bytes of class 'numeric')
[01:28:53.543] - globals: [1] 'kk'
[01:28:53.543] 
[01:28:53.543] getGlobalsAndPackages() ... DONE
[01:28:53.543] run() for 'Future' ...
[01:28:53.544] - state: 'created'
[01:28:53.544] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:53.544] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:53.545] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:53.545]   - Field: 'label'
[01:28:53.545]   - Field: 'local'
[01:28:53.545]   - Field: 'owner'
[01:28:53.545]   - Field: 'envir'
[01:28:53.546]   - Field: 'packages'
[01:28:53.546]   - Field: 'gc'
[01:28:53.546]   - Field: 'conditions'
[01:28:53.546]   - Field: 'expr'
[01:28:53.546]   - Field: 'uuid'
[01:28:53.547]   - Field: 'seed'
[01:28:53.547]   - Field: 'version'
[01:28:53.547]   - Field: 'result'
[01:28:53.547]   - Field: 'asynchronous'
[01:28:53.547]   - Field: 'calls'
[01:28:53.547]   - Field: 'globals'
[01:28:53.548]   - Field: 'stdout'
[01:28:53.548]   - Field: 'earlySignal'
[01:28:53.548]   - Field: 'lazy'
[01:28:53.548]   - Field: 'state'
[01:28:53.548] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:53.549] - Launch lazy future ...
[01:28:53.549] Packages needed by the future expression (n = 0): <none>
[01:28:53.549] Packages needed by future strategies (n = 0): <none>
[01:28:53.550] {
[01:28:53.550]     {
[01:28:53.550]         {
[01:28:53.550]             ...future.startTime <- base::Sys.time()
[01:28:53.550]             {
[01:28:53.550]                 {
[01:28:53.550]                   {
[01:28:53.550]                     base::local({
[01:28:53.550]                       has_future <- base::requireNamespace("future", 
[01:28:53.550]                         quietly = TRUE)
[01:28:53.550]                       if (has_future) {
[01:28:53.550]                         ns <- base::getNamespace("future")
[01:28:53.550]                         version <- ns[[".package"]][["version"]]
[01:28:53.550]                         if (is.null(version)) 
[01:28:53.550]                           version <- utils::packageVersion("future")
[01:28:53.550]                       }
[01:28:53.550]                       else {
[01:28:53.550]                         version <- NULL
[01:28:53.550]                       }
[01:28:53.550]                       if (!has_future || version < "1.8.0") {
[01:28:53.550]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:53.550]                           "", base::R.version$version.string), 
[01:28:53.550]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:53.550]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:53.550]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:53.550]                             "release", "version")], collapse = " "), 
[01:28:53.550]                           hostname = base::Sys.info()[["nodename"]])
[01:28:53.550]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:53.550]                           info)
[01:28:53.550]                         info <- base::paste(info, collapse = "; ")
[01:28:53.550]                         if (!has_future) {
[01:28:53.550]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:53.550]                             info)
[01:28:53.550]                         }
[01:28:53.550]                         else {
[01:28:53.550]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:53.550]                             info, version)
[01:28:53.550]                         }
[01:28:53.550]                         base::stop(msg)
[01:28:53.550]                       }
[01:28:53.550]                     })
[01:28:53.550]                   }
[01:28:53.550]                   options(future.plan = NULL)
[01:28:53.550]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:53.550]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:53.550]                 }
[01:28:53.550]                 ...future.workdir <- getwd()
[01:28:53.550]             }
[01:28:53.550]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:53.550]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:53.550]         }
[01:28:53.550]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:53.550]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:53.550]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:53.550]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:53.550]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:53.550]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:53.550]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:53.550]             base::names(...future.oldOptions))
[01:28:53.550]     }
[01:28:53.550]     if (FALSE) {
[01:28:53.550]     }
[01:28:53.550]     else {
[01:28:53.550]         if (TRUE) {
[01:28:53.550]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:53.550]                 open = "w")
[01:28:53.550]         }
[01:28:53.550]         else {
[01:28:53.550]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:53.550]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:53.550]         }
[01:28:53.550]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:53.550]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:53.550]             base::sink(type = "output", split = FALSE)
[01:28:53.550]             base::close(...future.stdout)
[01:28:53.550]         }, add = TRUE)
[01:28:53.550]     }
[01:28:53.550]     ...future.frame <- base::sys.nframe()
[01:28:53.550]     ...future.conditions <- base::list()
[01:28:53.550]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:53.550]     if (FALSE) {
[01:28:53.550]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:53.550]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:53.550]     }
[01:28:53.550]     ...future.result <- base::tryCatch({
[01:28:53.550]         base::withCallingHandlers({
[01:28:53.550]             ...future.value <- base::withVisible(base::local({
[01:28:53.550]                 Sys.sleep(0.1)
[01:28:53.550]                 kk
[01:28:53.550]             }))
[01:28:53.550]             future::FutureResult(value = ...future.value$value, 
[01:28:53.550]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:53.550]                   ...future.rng), globalenv = if (FALSE) 
[01:28:53.550]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:53.550]                     ...future.globalenv.names))
[01:28:53.550]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:53.550]         }, condition = base::local({
[01:28:53.550]             c <- base::c
[01:28:53.550]             inherits <- base::inherits
[01:28:53.550]             invokeRestart <- base::invokeRestart
[01:28:53.550]             length <- base::length
[01:28:53.550]             list <- base::list
[01:28:53.550]             seq.int <- base::seq.int
[01:28:53.550]             signalCondition <- base::signalCondition
[01:28:53.550]             sys.calls <- base::sys.calls
[01:28:53.550]             `[[` <- base::`[[`
[01:28:53.550]             `+` <- base::`+`
[01:28:53.550]             `<<-` <- base::`<<-`
[01:28:53.550]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:53.550]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:53.550]                   3L)]
[01:28:53.550]             }
[01:28:53.550]             function(cond) {
[01:28:53.550]                 is_error <- inherits(cond, "error")
[01:28:53.550]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:53.550]                   NULL)
[01:28:53.550]                 if (is_error) {
[01:28:53.550]                   sessionInformation <- function() {
[01:28:53.550]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:53.550]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:53.550]                       search = base::search(), system = base::Sys.info())
[01:28:53.550]                   }
[01:28:53.550]                   ...future.conditions[[length(...future.conditions) + 
[01:28:53.550]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:53.550]                     cond$call), session = sessionInformation(), 
[01:28:53.550]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:53.550]                   signalCondition(cond)
[01:28:53.550]                 }
[01:28:53.550]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:53.550]                 "immediateCondition"))) {
[01:28:53.550]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:53.550]                   ...future.conditions[[length(...future.conditions) + 
[01:28:53.550]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:53.550]                   if (TRUE && !signal) {
[01:28:53.550]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:53.550]                     {
[01:28:53.550]                       inherits <- base::inherits
[01:28:53.550]                       invokeRestart <- base::invokeRestart
[01:28:53.550]                       is.null <- base::is.null
[01:28:53.550]                       muffled <- FALSE
[01:28:53.550]                       if (inherits(cond, "message")) {
[01:28:53.550]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:53.550]                         if (muffled) 
[01:28:53.550]                           invokeRestart("muffleMessage")
[01:28:53.550]                       }
[01:28:53.550]                       else if (inherits(cond, "warning")) {
[01:28:53.550]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:53.550]                         if (muffled) 
[01:28:53.550]                           invokeRestart("muffleWarning")
[01:28:53.550]                       }
[01:28:53.550]                       else if (inherits(cond, "condition")) {
[01:28:53.550]                         if (!is.null(pattern)) {
[01:28:53.550]                           computeRestarts <- base::computeRestarts
[01:28:53.550]                           grepl <- base::grepl
[01:28:53.550]                           restarts <- computeRestarts(cond)
[01:28:53.550]                           for (restart in restarts) {
[01:28:53.550]                             name <- restart$name
[01:28:53.550]                             if (is.null(name)) 
[01:28:53.550]                               next
[01:28:53.550]                             if (!grepl(pattern, name)) 
[01:28:53.550]                               next
[01:28:53.550]                             invokeRestart(restart)
[01:28:53.550]                             muffled <- TRUE
[01:28:53.550]                             break
[01:28:53.550]                           }
[01:28:53.550]                         }
[01:28:53.550]                       }
[01:28:53.550]                       invisible(muffled)
[01:28:53.550]                     }
[01:28:53.550]                     muffleCondition(cond, pattern = "^muffle")
[01:28:53.550]                   }
[01:28:53.550]                 }
[01:28:53.550]                 else {
[01:28:53.550]                   if (TRUE) {
[01:28:53.550]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:53.550]                     {
[01:28:53.550]                       inherits <- base::inherits
[01:28:53.550]                       invokeRestart <- base::invokeRestart
[01:28:53.550]                       is.null <- base::is.null
[01:28:53.550]                       muffled <- FALSE
[01:28:53.550]                       if (inherits(cond, "message")) {
[01:28:53.550]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:53.550]                         if (muffled) 
[01:28:53.550]                           invokeRestart("muffleMessage")
[01:28:53.550]                       }
[01:28:53.550]                       else if (inherits(cond, "warning")) {
[01:28:53.550]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:53.550]                         if (muffled) 
[01:28:53.550]                           invokeRestart("muffleWarning")
[01:28:53.550]                       }
[01:28:53.550]                       else if (inherits(cond, "condition")) {
[01:28:53.550]                         if (!is.null(pattern)) {
[01:28:53.550]                           computeRestarts <- base::computeRestarts
[01:28:53.550]                           grepl <- base::grepl
[01:28:53.550]                           restarts <- computeRestarts(cond)
[01:28:53.550]                           for (restart in restarts) {
[01:28:53.550]                             name <- restart$name
[01:28:53.550]                             if (is.null(name)) 
[01:28:53.550]                               next
[01:28:53.550]                             if (!grepl(pattern, name)) 
[01:28:53.550]                               next
[01:28:53.550]                             invokeRestart(restart)
[01:28:53.550]                             muffled <- TRUE
[01:28:53.550]                             break
[01:28:53.550]                           }
[01:28:53.550]                         }
[01:28:53.550]                       }
[01:28:53.550]                       invisible(muffled)
[01:28:53.550]                     }
[01:28:53.550]                     muffleCondition(cond, pattern = "^muffle")
[01:28:53.550]                   }
[01:28:53.550]                 }
[01:28:53.550]             }
[01:28:53.550]         }))
[01:28:53.550]     }, error = function(ex) {
[01:28:53.550]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:53.550]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:53.550]                 ...future.rng), started = ...future.startTime, 
[01:28:53.550]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:53.550]             version = "1.8"), class = "FutureResult")
[01:28:53.550]     }, finally = {
[01:28:53.550]         if (!identical(...future.workdir, getwd())) 
[01:28:53.550]             setwd(...future.workdir)
[01:28:53.550]         {
[01:28:53.550]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:53.550]                 ...future.oldOptions$nwarnings <- NULL
[01:28:53.550]             }
[01:28:53.550]             base::options(...future.oldOptions)
[01:28:53.550]             if (.Platform$OS.type == "windows") {
[01:28:53.550]                 old_names <- names(...future.oldEnvVars)
[01:28:53.550]                 envs <- base::Sys.getenv()
[01:28:53.550]                 names <- names(envs)
[01:28:53.550]                 common <- intersect(names, old_names)
[01:28:53.550]                 added <- setdiff(names, old_names)
[01:28:53.550]                 removed <- setdiff(old_names, names)
[01:28:53.550]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:53.550]                   envs[common]]
[01:28:53.550]                 NAMES <- toupper(changed)
[01:28:53.550]                 args <- list()
[01:28:53.550]                 for (kk in seq_along(NAMES)) {
[01:28:53.550]                   name <- changed[[kk]]
[01:28:53.550]                   NAME <- NAMES[[kk]]
[01:28:53.550]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:53.550]                     next
[01:28:53.550]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:53.550]                 }
[01:28:53.550]                 NAMES <- toupper(added)
[01:28:53.550]                 for (kk in seq_along(NAMES)) {
[01:28:53.550]                   name <- added[[kk]]
[01:28:53.550]                   NAME <- NAMES[[kk]]
[01:28:53.550]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:53.550]                     next
[01:28:53.550]                   args[[name]] <- ""
[01:28:53.550]                 }
[01:28:53.550]                 NAMES <- toupper(removed)
[01:28:53.550]                 for (kk in seq_along(NAMES)) {
[01:28:53.550]                   name <- removed[[kk]]
[01:28:53.550]                   NAME <- NAMES[[kk]]
[01:28:53.550]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:53.550]                     next
[01:28:53.550]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:53.550]                 }
[01:28:53.550]                 if (length(args) > 0) 
[01:28:53.550]                   base::do.call(base::Sys.setenv, args = args)
[01:28:53.550]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:53.550]             }
[01:28:53.550]             else {
[01:28:53.550]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:53.550]             }
[01:28:53.550]             {
[01:28:53.550]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:53.550]                   0L) {
[01:28:53.550]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:53.550]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:53.550]                   base::options(opts)
[01:28:53.550]                 }
[01:28:53.550]                 {
[01:28:53.550]                   {
[01:28:53.550]                     NULL
[01:28:53.550]                     RNGkind("Mersenne-Twister")
[01:28:53.550]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:53.550]                       inherits = FALSE)
[01:28:53.550]                   }
[01:28:53.550]                   options(future.plan = NULL)
[01:28:53.550]                   if (is.na(NA_character_)) 
[01:28:53.550]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:53.550]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:53.550]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:53.550]                   {
[01:28:53.550]                     future <- SequentialFuture(..., envir = envir)
[01:28:53.550]                     if (!future$lazy) 
[01:28:53.550]                       future <- run(future)
[01:28:53.550]                     invisible(future)
[01:28:53.550]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:53.550]                 }
[01:28:53.550]             }
[01:28:53.550]         }
[01:28:53.550]     })
[01:28:53.550]     if (TRUE) {
[01:28:53.550]         base::sink(type = "output", split = FALSE)
[01:28:53.550]         if (TRUE) {
[01:28:53.550]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:53.550]         }
[01:28:53.550]         else {
[01:28:53.550]             ...future.result["stdout"] <- base::list(NULL)
[01:28:53.550]         }
[01:28:53.550]         base::close(...future.stdout)
[01:28:53.550]         ...future.stdout <- NULL
[01:28:53.550]     }
[01:28:53.550]     ...future.result$conditions <- ...future.conditions
[01:28:53.550]     ...future.result$finished <- base::Sys.time()
[01:28:53.550]     ...future.result
[01:28:53.550] }
[01:28:53.554] assign_globals() ...
[01:28:53.554] List of 1
[01:28:53.554]  $ kk: int 1
[01:28:53.554]  - attr(*, "where")=List of 1
[01:28:53.554]   ..$ kk:<environment: R_EmptyEnv> 
[01:28:53.554]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:53.554]  - attr(*, "resolved")= logi FALSE
[01:28:53.554]  - attr(*, "total_size")= num 56
[01:28:53.554]  - attr(*, "already-done")= logi TRUE
[01:28:53.560] - copied 'kk' to environment
[01:28:53.560] assign_globals() ... done
[01:28:53.561] plan(): Setting new future strategy stack:
[01:28:53.561] List of future strategies:
[01:28:53.561] 1. sequential:
[01:28:53.561]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:53.561]    - tweaked: FALSE
[01:28:53.561]    - call: NULL
[01:28:53.562] plan(): nbrOfWorkers() = 1
[01:28:53.671] plan(): Setting new future strategy stack:
[01:28:53.671] List of future strategies:
[01:28:53.671] 1. sequential:
[01:28:53.671]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:53.671]    - tweaked: FALSE
[01:28:53.671]    - call: plan(strategy)
[01:28:53.672] plan(): nbrOfWorkers() = 1
[01:28:53.672] SequentialFuture started (and completed)
[01:28:53.673] - Launch lazy future ... done
[01:28:53.673] run() for 'SequentialFuture' ... done
[01:28:53.673] getGlobalsAndPackages() ...
[01:28:53.673] Searching for globals...
[01:28:53.678] - globals found: [3] '{', 'Sys.sleep', 'kk'
[01:28:53.678] Searching for globals ... DONE
[01:28:53.678] Resolving globals: FALSE
[01:28:53.679] The total size of the 1 globals is 56 bytes (56 bytes)
[01:28:53.679] The total size of the 1 globals exported for future expression ('{; Sys.sleep(0.1); kk; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'kk' (56 bytes of class 'numeric')
[01:28:53.679] - globals: [1] 'kk'
[01:28:53.680] 
[01:28:53.680] getGlobalsAndPackages() ... DONE
[01:28:53.680] run() for 'Future' ...
[01:28:53.680] - state: 'created'
[01:28:53.681] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:53.681] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:53.681] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:53.681]   - Field: 'label'
[01:28:53.682]   - Field: 'local'
[01:28:53.682]   - Field: 'owner'
[01:28:53.682]   - Field: 'envir'
[01:28:53.682]   - Field: 'packages'
[01:28:53.682]   - Field: 'gc'
[01:28:53.683]   - Field: 'conditions'
[01:28:53.683]   - Field: 'expr'
[01:28:53.683]   - Field: 'uuid'
[01:28:53.683]   - Field: 'seed'
[01:28:53.683]   - Field: 'version'
[01:28:53.683]   - Field: 'result'
[01:28:53.684]   - Field: 'asynchronous'
[01:28:53.684]   - Field: 'calls'
[01:28:53.684]   - Field: 'globals'
[01:28:53.684]   - Field: 'stdout'
[01:28:53.684]   - Field: 'earlySignal'
[01:28:53.685]   - Field: 'lazy'
[01:28:53.685]   - Field: 'state'
[01:28:53.685] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:53.685] - Launch lazy future ...
[01:28:53.685] Packages needed by the future expression (n = 0): <none>
[01:28:53.686] Packages needed by future strategies (n = 0): <none>
[01:28:53.686] {
[01:28:53.686]     {
[01:28:53.686]         {
[01:28:53.686]             ...future.startTime <- base::Sys.time()
[01:28:53.686]             {
[01:28:53.686]                 {
[01:28:53.686]                   {
[01:28:53.686]                     base::local({
[01:28:53.686]                       has_future <- base::requireNamespace("future", 
[01:28:53.686]                         quietly = TRUE)
[01:28:53.686]                       if (has_future) {
[01:28:53.686]                         ns <- base::getNamespace("future")
[01:28:53.686]                         version <- ns[[".package"]][["version"]]
[01:28:53.686]                         if (is.null(version)) 
[01:28:53.686]                           version <- utils::packageVersion("future")
[01:28:53.686]                       }
[01:28:53.686]                       else {
[01:28:53.686]                         version <- NULL
[01:28:53.686]                       }
[01:28:53.686]                       if (!has_future || version < "1.8.0") {
[01:28:53.686]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:53.686]                           "", base::R.version$version.string), 
[01:28:53.686]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:53.686]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:53.686]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:53.686]                             "release", "version")], collapse = " "), 
[01:28:53.686]                           hostname = base::Sys.info()[["nodename"]])
[01:28:53.686]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:53.686]                           info)
[01:28:53.686]                         info <- base::paste(info, collapse = "; ")
[01:28:53.686]                         if (!has_future) {
[01:28:53.686]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:53.686]                             info)
[01:28:53.686]                         }
[01:28:53.686]                         else {
[01:28:53.686]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:53.686]                             info, version)
[01:28:53.686]                         }
[01:28:53.686]                         base::stop(msg)
[01:28:53.686]                       }
[01:28:53.686]                     })
[01:28:53.686]                   }
[01:28:53.686]                   options(future.plan = NULL)
[01:28:53.686]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:53.686]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:53.686]                 }
[01:28:53.686]                 ...future.workdir <- getwd()
[01:28:53.686]             }
[01:28:53.686]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:53.686]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:53.686]         }
[01:28:53.686]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:53.686]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:53.686]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:53.686]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:53.686]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:53.686]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:53.686]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:53.686]             base::names(...future.oldOptions))
[01:28:53.686]     }
[01:28:53.686]     if (FALSE) {
[01:28:53.686]     }
[01:28:53.686]     else {
[01:28:53.686]         if (TRUE) {
[01:28:53.686]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:53.686]                 open = "w")
[01:28:53.686]         }
[01:28:53.686]         else {
[01:28:53.686]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:53.686]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:53.686]         }
[01:28:53.686]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:53.686]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:53.686]             base::sink(type = "output", split = FALSE)
[01:28:53.686]             base::close(...future.stdout)
[01:28:53.686]         }, add = TRUE)
[01:28:53.686]     }
[01:28:53.686]     ...future.frame <- base::sys.nframe()
[01:28:53.686]     ...future.conditions <- base::list()
[01:28:53.686]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:53.686]     if (FALSE) {
[01:28:53.686]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:53.686]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:53.686]     }
[01:28:53.686]     ...future.result <- base::tryCatch({
[01:28:53.686]         base::withCallingHandlers({
[01:28:53.686]             ...future.value <- base::withVisible(base::local({
[01:28:53.686]                 Sys.sleep(0.1)
[01:28:53.686]                 kk
[01:28:53.686]             }))
[01:28:53.686]             future::FutureResult(value = ...future.value$value, 
[01:28:53.686]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:53.686]                   ...future.rng), globalenv = if (FALSE) 
[01:28:53.686]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:53.686]                     ...future.globalenv.names))
[01:28:53.686]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:53.686]         }, condition = base::local({
[01:28:53.686]             c <- base::c
[01:28:53.686]             inherits <- base::inherits
[01:28:53.686]             invokeRestart <- base::invokeRestart
[01:28:53.686]             length <- base::length
[01:28:53.686]             list <- base::list
[01:28:53.686]             seq.int <- base::seq.int
[01:28:53.686]             signalCondition <- base::signalCondition
[01:28:53.686]             sys.calls <- base::sys.calls
[01:28:53.686]             `[[` <- base::`[[`
[01:28:53.686]             `+` <- base::`+`
[01:28:53.686]             `<<-` <- base::`<<-`
[01:28:53.686]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:53.686]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:53.686]                   3L)]
[01:28:53.686]             }
[01:28:53.686]             function(cond) {
[01:28:53.686]                 is_error <- inherits(cond, "error")
[01:28:53.686]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:53.686]                   NULL)
[01:28:53.686]                 if (is_error) {
[01:28:53.686]                   sessionInformation <- function() {
[01:28:53.686]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:53.686]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:53.686]                       search = base::search(), system = base::Sys.info())
[01:28:53.686]                   }
[01:28:53.686]                   ...future.conditions[[length(...future.conditions) + 
[01:28:53.686]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:53.686]                     cond$call), session = sessionInformation(), 
[01:28:53.686]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:53.686]                   signalCondition(cond)
[01:28:53.686]                 }
[01:28:53.686]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:53.686]                 "immediateCondition"))) {
[01:28:53.686]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:53.686]                   ...future.conditions[[length(...future.conditions) + 
[01:28:53.686]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:53.686]                   if (TRUE && !signal) {
[01:28:53.686]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:53.686]                     {
[01:28:53.686]                       inherits <- base::inherits
[01:28:53.686]                       invokeRestart <- base::invokeRestart
[01:28:53.686]                       is.null <- base::is.null
[01:28:53.686]                       muffled <- FALSE
[01:28:53.686]                       if (inherits(cond, "message")) {
[01:28:53.686]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:53.686]                         if (muffled) 
[01:28:53.686]                           invokeRestart("muffleMessage")
[01:28:53.686]                       }
[01:28:53.686]                       else if (inherits(cond, "warning")) {
[01:28:53.686]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:53.686]                         if (muffled) 
[01:28:53.686]                           invokeRestart("muffleWarning")
[01:28:53.686]                       }
[01:28:53.686]                       else if (inherits(cond, "condition")) {
[01:28:53.686]                         if (!is.null(pattern)) {
[01:28:53.686]                           computeRestarts <- base::computeRestarts
[01:28:53.686]                           grepl <- base::grepl
[01:28:53.686]                           restarts <- computeRestarts(cond)
[01:28:53.686]                           for (restart in restarts) {
[01:28:53.686]                             name <- restart$name
[01:28:53.686]                             if (is.null(name)) 
[01:28:53.686]                               next
[01:28:53.686]                             if (!grepl(pattern, name)) 
[01:28:53.686]                               next
[01:28:53.686]                             invokeRestart(restart)
[01:28:53.686]                             muffled <- TRUE
[01:28:53.686]                             break
[01:28:53.686]                           }
[01:28:53.686]                         }
[01:28:53.686]                       }
[01:28:53.686]                       invisible(muffled)
[01:28:53.686]                     }
[01:28:53.686]                     muffleCondition(cond, pattern = "^muffle")
[01:28:53.686]                   }
[01:28:53.686]                 }
[01:28:53.686]                 else {
[01:28:53.686]                   if (TRUE) {
[01:28:53.686]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:53.686]                     {
[01:28:53.686]                       inherits <- base::inherits
[01:28:53.686]                       invokeRestart <- base::invokeRestart
[01:28:53.686]                       is.null <- base::is.null
[01:28:53.686]                       muffled <- FALSE
[01:28:53.686]                       if (inherits(cond, "message")) {
[01:28:53.686]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:53.686]                         if (muffled) 
[01:28:53.686]                           invokeRestart("muffleMessage")
[01:28:53.686]                       }
[01:28:53.686]                       else if (inherits(cond, "warning")) {
[01:28:53.686]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:53.686]                         if (muffled) 
[01:28:53.686]                           invokeRestart("muffleWarning")
[01:28:53.686]                       }
[01:28:53.686]                       else if (inherits(cond, "condition")) {
[01:28:53.686]                         if (!is.null(pattern)) {
[01:28:53.686]                           computeRestarts <- base::computeRestarts
[01:28:53.686]                           grepl <- base::grepl
[01:28:53.686]                           restarts <- computeRestarts(cond)
[01:28:53.686]                           for (restart in restarts) {
[01:28:53.686]                             name <- restart$name
[01:28:53.686]                             if (is.null(name)) 
[01:28:53.686]                               next
[01:28:53.686]                             if (!grepl(pattern, name)) 
[01:28:53.686]                               next
[01:28:53.686]                             invokeRestart(restart)
[01:28:53.686]                             muffled <- TRUE
[01:28:53.686]                             break
[01:28:53.686]                           }
[01:28:53.686]                         }
[01:28:53.686]                       }
[01:28:53.686]                       invisible(muffled)
[01:28:53.686]                     }
[01:28:53.686]                     muffleCondition(cond, pattern = "^muffle")
[01:28:53.686]                   }
[01:28:53.686]                 }
[01:28:53.686]             }
[01:28:53.686]         }))
[01:28:53.686]     }, error = function(ex) {
[01:28:53.686]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:53.686]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:53.686]                 ...future.rng), started = ...future.startTime, 
[01:28:53.686]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:53.686]             version = "1.8"), class = "FutureResult")
[01:28:53.686]     }, finally = {
[01:28:53.686]         if (!identical(...future.workdir, getwd())) 
[01:28:53.686]             setwd(...future.workdir)
[01:28:53.686]         {
[01:28:53.686]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:53.686]                 ...future.oldOptions$nwarnings <- NULL
[01:28:53.686]             }
[01:28:53.686]             base::options(...future.oldOptions)
[01:28:53.686]             if (.Platform$OS.type == "windows") {
[01:28:53.686]                 old_names <- names(...future.oldEnvVars)
[01:28:53.686]                 envs <- base::Sys.getenv()
[01:28:53.686]                 names <- names(envs)
[01:28:53.686]                 common <- intersect(names, old_names)
[01:28:53.686]                 added <- setdiff(names, old_names)
[01:28:53.686]                 removed <- setdiff(old_names, names)
[01:28:53.686]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:53.686]                   envs[common]]
[01:28:53.686]                 NAMES <- toupper(changed)
[01:28:53.686]                 args <- list()
[01:28:53.686]                 for (kk in seq_along(NAMES)) {
[01:28:53.686]                   name <- changed[[kk]]
[01:28:53.686]                   NAME <- NAMES[[kk]]
[01:28:53.686]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:53.686]                     next
[01:28:53.686]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:53.686]                 }
[01:28:53.686]                 NAMES <- toupper(added)
[01:28:53.686]                 for (kk in seq_along(NAMES)) {
[01:28:53.686]                   name <- added[[kk]]
[01:28:53.686]                   NAME <- NAMES[[kk]]
[01:28:53.686]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:53.686]                     next
[01:28:53.686]                   args[[name]] <- ""
[01:28:53.686]                 }
[01:28:53.686]                 NAMES <- toupper(removed)
[01:28:53.686]                 for (kk in seq_along(NAMES)) {
[01:28:53.686]                   name <- removed[[kk]]
[01:28:53.686]                   NAME <- NAMES[[kk]]
[01:28:53.686]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:53.686]                     next
[01:28:53.686]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:53.686]                 }
[01:28:53.686]                 if (length(args) > 0) 
[01:28:53.686]                   base::do.call(base::Sys.setenv, args = args)
[01:28:53.686]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:53.686]             }
[01:28:53.686]             else {
[01:28:53.686]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:53.686]             }
[01:28:53.686]             {
[01:28:53.686]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:53.686]                   0L) {
[01:28:53.686]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:53.686]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:53.686]                   base::options(opts)
[01:28:53.686]                 }
[01:28:53.686]                 {
[01:28:53.686]                   {
[01:28:53.686]                     NULL
[01:28:53.686]                     RNGkind("Mersenne-Twister")
[01:28:53.686]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:53.686]                       inherits = FALSE)
[01:28:53.686]                   }
[01:28:53.686]                   options(future.plan = NULL)
[01:28:53.686]                   if (is.na(NA_character_)) 
[01:28:53.686]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:53.686]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:53.686]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:53.686]                   {
[01:28:53.686]                     future <- SequentialFuture(..., envir = envir)
[01:28:53.686]                     if (!future$lazy) 
[01:28:53.686]                       future <- run(future)
[01:28:53.686]                     invisible(future)
[01:28:53.686]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:53.686]                 }
[01:28:53.686]             }
[01:28:53.686]         }
[01:28:53.686]     })
[01:28:53.686]     if (TRUE) {
[01:28:53.686]         base::sink(type = "output", split = FALSE)
[01:28:53.686]         if (TRUE) {
[01:28:53.686]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:53.686]         }
[01:28:53.686]         else {
[01:28:53.686]             ...future.result["stdout"] <- base::list(NULL)
[01:28:53.686]         }
[01:28:53.686]         base::close(...future.stdout)
[01:28:53.686]         ...future.stdout <- NULL
[01:28:53.686]     }
[01:28:53.686]     ...future.result$conditions <- ...future.conditions
[01:28:53.686]     ...future.result$finished <- base::Sys.time()
[01:28:53.686]     ...future.result
[01:28:53.686] }
[01:28:53.690] assign_globals() ...
[01:28:53.690] List of 1
[01:28:53.690]  $ kk: int 2
[01:28:53.690]  - attr(*, "where")=List of 1
[01:28:53.690]   ..$ kk:<environment: R_EmptyEnv> 
[01:28:53.690]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:53.690]  - attr(*, "resolved")= logi FALSE
[01:28:53.690]  - attr(*, "total_size")= num 56
[01:28:53.690]  - attr(*, "already-done")= logi TRUE
[01:28:53.694] - copied 'kk' to environment
[01:28:53.694] assign_globals() ... done
[01:28:53.694] plan(): Setting new future strategy stack:
[01:28:53.694] List of future strategies:
[01:28:53.694] 1. sequential:
[01:28:53.694]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:53.694]    - tweaked: FALSE
[01:28:53.694]    - call: NULL
[01:28:53.695] plan(): nbrOfWorkers() = 1
[01:28:53.812] plan(): Setting new future strategy stack:
[01:28:53.812] List of future strategies:
[01:28:53.812] 1. sequential:
[01:28:53.812]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:53.812]    - tweaked: FALSE
[01:28:53.812]    - call: plan(strategy)
[01:28:53.813] plan(): nbrOfWorkers() = 1
[01:28:53.813] SequentialFuture started (and completed)
[01:28:53.814] - Launch lazy future ... done
[01:28:53.814] run() for 'SequentialFuture' ... done
[01:28:53.814] getGlobalsAndPackages() ...
[01:28:53.814] Searching for globals...
[01:28:53.816] - globals found: [3] '{', 'Sys.sleep', 'kk'
[01:28:53.816] Searching for globals ... DONE
[01:28:53.816] Resolving globals: FALSE
[01:28:53.817] The total size of the 1 globals is 56 bytes (56 bytes)
[01:28:53.817] The total size of the 1 globals exported for future expression ('{; Sys.sleep(0.1); kk; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'kk' (56 bytes of class 'numeric')
[01:28:53.817] - globals: [1] 'kk'
[01:28:53.818] 
[01:28:53.818] getGlobalsAndPackages() ... DONE
[01:28:53.818] run() for 'Future' ...
[01:28:53.818] - state: 'created'
[01:28:53.819] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:53.819] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:53.819] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:53.819]   - Field: 'label'
[01:28:53.819]   - Field: 'local'
[01:28:53.820]   - Field: 'owner'
[01:28:53.820]   - Field: 'envir'
[01:28:53.820]   - Field: 'packages'
[01:28:53.820]   - Field: 'gc'
[01:28:53.820]   - Field: 'conditions'
[01:28:53.821]   - Field: 'expr'
[01:28:53.821]   - Field: 'uuid'
[01:28:53.821]   - Field: 'seed'
[01:28:53.821]   - Field: 'version'
[01:28:53.821]   - Field: 'result'
[01:28:53.821]   - Field: 'asynchronous'
[01:28:53.822]   - Field: 'calls'
[01:28:53.822]   - Field: 'globals'
[01:28:53.822]   - Field: 'stdout'
[01:28:53.822]   - Field: 'earlySignal'
[01:28:53.822]   - Field: 'lazy'
[01:28:53.822]   - Field: 'state'
[01:28:53.823] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:53.823] - Launch lazy future ...
[01:28:53.823] Packages needed by the future expression (n = 0): <none>
[01:28:53.823] Packages needed by future strategies (n = 0): <none>
[01:28:53.824] {
[01:28:53.824]     {
[01:28:53.824]         {
[01:28:53.824]             ...future.startTime <- base::Sys.time()
[01:28:53.824]             {
[01:28:53.824]                 {
[01:28:53.824]                   {
[01:28:53.824]                     base::local({
[01:28:53.824]                       has_future <- base::requireNamespace("future", 
[01:28:53.824]                         quietly = TRUE)
[01:28:53.824]                       if (has_future) {
[01:28:53.824]                         ns <- base::getNamespace("future")
[01:28:53.824]                         version <- ns[[".package"]][["version"]]
[01:28:53.824]                         if (is.null(version)) 
[01:28:53.824]                           version <- utils::packageVersion("future")
[01:28:53.824]                       }
[01:28:53.824]                       else {
[01:28:53.824]                         version <- NULL
[01:28:53.824]                       }
[01:28:53.824]                       if (!has_future || version < "1.8.0") {
[01:28:53.824]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:53.824]                           "", base::R.version$version.string), 
[01:28:53.824]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:53.824]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:53.824]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:53.824]                             "release", "version")], collapse = " "), 
[01:28:53.824]                           hostname = base::Sys.info()[["nodename"]])
[01:28:53.824]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:53.824]                           info)
[01:28:53.824]                         info <- base::paste(info, collapse = "; ")
[01:28:53.824]                         if (!has_future) {
[01:28:53.824]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:53.824]                             info)
[01:28:53.824]                         }
[01:28:53.824]                         else {
[01:28:53.824]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:53.824]                             info, version)
[01:28:53.824]                         }
[01:28:53.824]                         base::stop(msg)
[01:28:53.824]                       }
[01:28:53.824]                     })
[01:28:53.824]                   }
[01:28:53.824]                   options(future.plan = NULL)
[01:28:53.824]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:53.824]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:53.824]                 }
[01:28:53.824]                 ...future.workdir <- getwd()
[01:28:53.824]             }
[01:28:53.824]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:53.824]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:53.824]         }
[01:28:53.824]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:53.824]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:53.824]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:53.824]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:53.824]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:53.824]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:53.824]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:53.824]             base::names(...future.oldOptions))
[01:28:53.824]     }
[01:28:53.824]     if (FALSE) {
[01:28:53.824]     }
[01:28:53.824]     else {
[01:28:53.824]         if (TRUE) {
[01:28:53.824]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:53.824]                 open = "w")
[01:28:53.824]         }
[01:28:53.824]         else {
[01:28:53.824]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:53.824]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:53.824]         }
[01:28:53.824]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:53.824]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:53.824]             base::sink(type = "output", split = FALSE)
[01:28:53.824]             base::close(...future.stdout)
[01:28:53.824]         }, add = TRUE)
[01:28:53.824]     }
[01:28:53.824]     ...future.frame <- base::sys.nframe()
[01:28:53.824]     ...future.conditions <- base::list()
[01:28:53.824]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:53.824]     if (FALSE) {
[01:28:53.824]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:53.824]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:53.824]     }
[01:28:53.824]     ...future.result <- base::tryCatch({
[01:28:53.824]         base::withCallingHandlers({
[01:28:53.824]             ...future.value <- base::withVisible(base::local({
[01:28:53.824]                 Sys.sleep(0.1)
[01:28:53.824]                 kk
[01:28:53.824]             }))
[01:28:53.824]             future::FutureResult(value = ...future.value$value, 
[01:28:53.824]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:53.824]                   ...future.rng), globalenv = if (FALSE) 
[01:28:53.824]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:53.824]                     ...future.globalenv.names))
[01:28:53.824]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:53.824]         }, condition = base::local({
[01:28:53.824]             c <- base::c
[01:28:53.824]             inherits <- base::inherits
[01:28:53.824]             invokeRestart <- base::invokeRestart
[01:28:53.824]             length <- base::length
[01:28:53.824]             list <- base::list
[01:28:53.824]             seq.int <- base::seq.int
[01:28:53.824]             signalCondition <- base::signalCondition
[01:28:53.824]             sys.calls <- base::sys.calls
[01:28:53.824]             `[[` <- base::`[[`
[01:28:53.824]             `+` <- base::`+`
[01:28:53.824]             `<<-` <- base::`<<-`
[01:28:53.824]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:53.824]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:53.824]                   3L)]
[01:28:53.824]             }
[01:28:53.824]             function(cond) {
[01:28:53.824]                 is_error <- inherits(cond, "error")
[01:28:53.824]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:53.824]                   NULL)
[01:28:53.824]                 if (is_error) {
[01:28:53.824]                   sessionInformation <- function() {
[01:28:53.824]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:53.824]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:53.824]                       search = base::search(), system = base::Sys.info())
[01:28:53.824]                   }
[01:28:53.824]                   ...future.conditions[[length(...future.conditions) + 
[01:28:53.824]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:53.824]                     cond$call), session = sessionInformation(), 
[01:28:53.824]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:53.824]                   signalCondition(cond)
[01:28:53.824]                 }
[01:28:53.824]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:53.824]                 "immediateCondition"))) {
[01:28:53.824]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:53.824]                   ...future.conditions[[length(...future.conditions) + 
[01:28:53.824]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:53.824]                   if (TRUE && !signal) {
[01:28:53.824]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:53.824]                     {
[01:28:53.824]                       inherits <- base::inherits
[01:28:53.824]                       invokeRestart <- base::invokeRestart
[01:28:53.824]                       is.null <- base::is.null
[01:28:53.824]                       muffled <- FALSE
[01:28:53.824]                       if (inherits(cond, "message")) {
[01:28:53.824]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:53.824]                         if (muffled) 
[01:28:53.824]                           invokeRestart("muffleMessage")
[01:28:53.824]                       }
[01:28:53.824]                       else if (inherits(cond, "warning")) {
[01:28:53.824]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:53.824]                         if (muffled) 
[01:28:53.824]                           invokeRestart("muffleWarning")
[01:28:53.824]                       }
[01:28:53.824]                       else if (inherits(cond, "condition")) {
[01:28:53.824]                         if (!is.null(pattern)) {
[01:28:53.824]                           computeRestarts <- base::computeRestarts
[01:28:53.824]                           grepl <- base::grepl
[01:28:53.824]                           restarts <- computeRestarts(cond)
[01:28:53.824]                           for (restart in restarts) {
[01:28:53.824]                             name <- restart$name
[01:28:53.824]                             if (is.null(name)) 
[01:28:53.824]                               next
[01:28:53.824]                             if (!grepl(pattern, name)) 
[01:28:53.824]                               next
[01:28:53.824]                             invokeRestart(restart)
[01:28:53.824]                             muffled <- TRUE
[01:28:53.824]                             break
[01:28:53.824]                           }
[01:28:53.824]                         }
[01:28:53.824]                       }
[01:28:53.824]                       invisible(muffled)
[01:28:53.824]                     }
[01:28:53.824]                     muffleCondition(cond, pattern = "^muffle")
[01:28:53.824]                   }
[01:28:53.824]                 }
[01:28:53.824]                 else {
[01:28:53.824]                   if (TRUE) {
[01:28:53.824]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:53.824]                     {
[01:28:53.824]                       inherits <- base::inherits
[01:28:53.824]                       invokeRestart <- base::invokeRestart
[01:28:53.824]                       is.null <- base::is.null
[01:28:53.824]                       muffled <- FALSE
[01:28:53.824]                       if (inherits(cond, "message")) {
[01:28:53.824]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:53.824]                         if (muffled) 
[01:28:53.824]                           invokeRestart("muffleMessage")
[01:28:53.824]                       }
[01:28:53.824]                       else if (inherits(cond, "warning")) {
[01:28:53.824]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:53.824]                         if (muffled) 
[01:28:53.824]                           invokeRestart("muffleWarning")
[01:28:53.824]                       }
[01:28:53.824]                       else if (inherits(cond, "condition")) {
[01:28:53.824]                         if (!is.null(pattern)) {
[01:28:53.824]                           computeRestarts <- base::computeRestarts
[01:28:53.824]                           grepl <- base::grepl
[01:28:53.824]                           restarts <- computeRestarts(cond)
[01:28:53.824]                           for (restart in restarts) {
[01:28:53.824]                             name <- restart$name
[01:28:53.824]                             if (is.null(name)) 
[01:28:53.824]                               next
[01:28:53.824]                             if (!grepl(pattern, name)) 
[01:28:53.824]                               next
[01:28:53.824]                             invokeRestart(restart)
[01:28:53.824]                             muffled <- TRUE
[01:28:53.824]                             break
[01:28:53.824]                           }
[01:28:53.824]                         }
[01:28:53.824]                       }
[01:28:53.824]                       invisible(muffled)
[01:28:53.824]                     }
[01:28:53.824]                     muffleCondition(cond, pattern = "^muffle")
[01:28:53.824]                   }
[01:28:53.824]                 }
[01:28:53.824]             }
[01:28:53.824]         }))
[01:28:53.824]     }, error = function(ex) {
[01:28:53.824]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:53.824]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:53.824]                 ...future.rng), started = ...future.startTime, 
[01:28:53.824]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:53.824]             version = "1.8"), class = "FutureResult")
[01:28:53.824]     }, finally = {
[01:28:53.824]         if (!identical(...future.workdir, getwd())) 
[01:28:53.824]             setwd(...future.workdir)
[01:28:53.824]         {
[01:28:53.824]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:53.824]                 ...future.oldOptions$nwarnings <- NULL
[01:28:53.824]             }
[01:28:53.824]             base::options(...future.oldOptions)
[01:28:53.824]             if (.Platform$OS.type == "windows") {
[01:28:53.824]                 old_names <- names(...future.oldEnvVars)
[01:28:53.824]                 envs <- base::Sys.getenv()
[01:28:53.824]                 names <- names(envs)
[01:28:53.824]                 common <- intersect(names, old_names)
[01:28:53.824]                 added <- setdiff(names, old_names)
[01:28:53.824]                 removed <- setdiff(old_names, names)
[01:28:53.824]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:53.824]                   envs[common]]
[01:28:53.824]                 NAMES <- toupper(changed)
[01:28:53.824]                 args <- list()
[01:28:53.824]                 for (kk in seq_along(NAMES)) {
[01:28:53.824]                   name <- changed[[kk]]
[01:28:53.824]                   NAME <- NAMES[[kk]]
[01:28:53.824]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:53.824]                     next
[01:28:53.824]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:53.824]                 }
[01:28:53.824]                 NAMES <- toupper(added)
[01:28:53.824]                 for (kk in seq_along(NAMES)) {
[01:28:53.824]                   name <- added[[kk]]
[01:28:53.824]                   NAME <- NAMES[[kk]]
[01:28:53.824]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:53.824]                     next
[01:28:53.824]                   args[[name]] <- ""
[01:28:53.824]                 }
[01:28:53.824]                 NAMES <- toupper(removed)
[01:28:53.824]                 for (kk in seq_along(NAMES)) {
[01:28:53.824]                   name <- removed[[kk]]
[01:28:53.824]                   NAME <- NAMES[[kk]]
[01:28:53.824]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:53.824]                     next
[01:28:53.824]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:53.824]                 }
[01:28:53.824]                 if (length(args) > 0) 
[01:28:53.824]                   base::do.call(base::Sys.setenv, args = args)
[01:28:53.824]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:53.824]             }
[01:28:53.824]             else {
[01:28:53.824]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:53.824]             }
[01:28:53.824]             {
[01:28:53.824]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:53.824]                   0L) {
[01:28:53.824]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:53.824]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:53.824]                   base::options(opts)
[01:28:53.824]                 }
[01:28:53.824]                 {
[01:28:53.824]                   {
[01:28:53.824]                     NULL
[01:28:53.824]                     RNGkind("Mersenne-Twister")
[01:28:53.824]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:53.824]                       inherits = FALSE)
[01:28:53.824]                   }
[01:28:53.824]                   options(future.plan = NULL)
[01:28:53.824]                   if (is.na(NA_character_)) 
[01:28:53.824]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:53.824]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:53.824]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:53.824]                   {
[01:28:53.824]                     future <- SequentialFuture(..., envir = envir)
[01:28:53.824]                     if (!future$lazy) 
[01:28:53.824]                       future <- run(future)
[01:28:53.824]                     invisible(future)
[01:28:53.824]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:53.824]                 }
[01:28:53.824]             }
[01:28:53.824]         }
[01:28:53.824]     })
[01:28:53.824]     if (TRUE) {
[01:28:53.824]         base::sink(type = "output", split = FALSE)
[01:28:53.824]         if (TRUE) {
[01:28:53.824]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:53.824]         }
[01:28:53.824]         else {
[01:28:53.824]             ...future.result["stdout"] <- base::list(NULL)
[01:28:53.824]         }
[01:28:53.824]         base::close(...future.stdout)
[01:28:53.824]         ...future.stdout <- NULL
[01:28:53.824]     }
[01:28:53.824]     ...future.result$conditions <- ...future.conditions
[01:28:53.824]     ...future.result$finished <- base::Sys.time()
[01:28:53.824]     ...future.result
[01:28:53.824] }
[01:28:53.828] assign_globals() ...
[01:28:53.828] List of 1
[01:28:53.828]  $ kk: int 3
[01:28:53.828]  - attr(*, "where")=List of 1
[01:28:53.828]   ..$ kk:<environment: R_EmptyEnv> 
[01:28:53.828]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:53.828]  - attr(*, "resolved")= logi FALSE
[01:28:53.828]  - attr(*, "total_size")= num 56
[01:28:53.828]  - attr(*, "already-done")= logi TRUE
[01:28:53.833] - copied 'kk' to environment
[01:28:53.833] assign_globals() ... done
[01:28:53.834] plan(): Setting new future strategy stack:
[01:28:53.834] List of future strategies:
[01:28:53.834] 1. sequential:
[01:28:53.834]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:53.834]    - tweaked: FALSE
[01:28:53.834]    - call: NULL
[01:28:53.835] plan(): nbrOfWorkers() = 1
[01:28:53.937] plan(): Setting new future strategy stack:
[01:28:53.937] List of future strategies:
[01:28:53.937] 1. sequential:
[01:28:53.937]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:53.937]    - tweaked: FALSE
[01:28:53.937]    - call: plan(strategy)
[01:28:53.938] plan(): nbrOfWorkers() = 1
[01:28:53.938] SequentialFuture started (and completed)
[01:28:53.938] - Launch lazy future ... done
[01:28:53.939] run() for 'SequentialFuture' ... done
[01:28:53.939] resolve() on list ...
[01:28:53.939]  recursive: 0
[01:28:53.939]  length: 3
[01:28:53.939] 
[01:28:53.940] resolved() for 'SequentialFuture' ...
[01:28:53.940] - state: 'finished'
[01:28:53.940] - run: TRUE
[01:28:53.940] - result: 'FutureResult'
[01:28:53.940] resolved() for 'SequentialFuture' ... done
[01:28:53.941] Future #1
[01:28:53.941]  length: 2 (resolved future 1)
[01:28:53.941] resolved() for 'SequentialFuture' ...
[01:28:53.941] - state: 'finished'
[01:28:53.941] - run: TRUE
[01:28:53.941] - result: 'FutureResult'
[01:28:53.942] resolved() for 'SequentialFuture' ... done
[01:28:53.942] Future #2
[01:28:53.942]  length: 1 (resolved future 2)
[01:28:53.942] resolved() for 'SequentialFuture' ...
[01:28:53.942] - state: 'finished'
[01:28:53.943] - run: TRUE
[01:28:53.943] - result: 'FutureResult'
[01:28:53.943] resolved() for 'SequentialFuture' ... done
[01:28:53.943] Future #3
[01:28:53.943]  length: 0 (resolved future 3)
[01:28:53.944] resolve() on list ... DONE
[01:28:53.944] getGlobalsAndPackages() ...
[01:28:53.944] Searching for globals...
[01:28:53.945] - globals found: [3] '{', 'Sys.sleep', 'kk'
[01:28:53.945] Searching for globals ... DONE
[01:28:53.946] Resolving globals: FALSE
[01:28:53.946] The total size of the 1 globals is 56 bytes (56 bytes)
[01:28:53.947] The total size of the 1 globals exported for future expression ('{; Sys.sleep(0.1); kk; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'kk' (56 bytes of class 'numeric')
[01:28:53.947] - globals: [1] 'kk'
[01:28:53.947] 
[01:28:53.947] getGlobalsAndPackages() ... DONE
[01:28:53.948] getGlobalsAndPackages() ...
[01:28:53.948] Searching for globals...
[01:28:53.949] - globals found: [3] '{', 'Sys.sleep', 'kk'
[01:28:53.949] Searching for globals ... DONE
[01:28:53.949] Resolving globals: FALSE
[01:28:53.950] The total size of the 1 globals is 56 bytes (56 bytes)
[01:28:53.950] The total size of the 1 globals exported for future expression ('{; Sys.sleep(0.1); kk; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'kk' (56 bytes of class 'numeric')
[01:28:53.951] - globals: [1] 'kk'
[01:28:53.951] 
[01:28:53.951] getGlobalsAndPackages() ... DONE
[01:28:53.951] getGlobalsAndPackages() ...
[01:28:53.951] Searching for globals...
[01:28:53.953] - globals found: [3] '{', 'Sys.sleep', 'kk'
[01:28:53.953] Searching for globals ... DONE
[01:28:53.953] Resolving globals: FALSE
[01:28:53.954] The total size of the 1 globals is 56 bytes (56 bytes)
[01:28:53.954] The total size of the 1 globals exported for future expression ('{; Sys.sleep(0.1); kk; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'kk' (56 bytes of class 'numeric')
[01:28:53.955] - globals: [1] 'kk'
[01:28:53.955] 
[01:28:53.955] getGlobalsAndPackages() ... DONE
[01:28:53.956] resolve() on list ...
[01:28:53.956]  recursive: 0
[01:28:53.956]  length: 3
[01:28:53.956] 
[01:28:53.956] run() for 'Future' ...
[01:28:53.956] - state: 'created'
[01:28:53.957] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:53.957] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:53.957] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:53.957]   - Field: 'label'
[01:28:53.958]   - Field: 'local'
[01:28:53.958]   - Field: 'owner'
[01:28:53.958]   - Field: 'envir'
[01:28:53.958]   - Field: 'packages'
[01:28:53.958]   - Field: 'gc'
[01:28:53.959]   - Field: 'conditions'
[01:28:53.959]   - Field: 'expr'
[01:28:53.959]   - Field: 'uuid'
[01:28:53.959]   - Field: 'seed'
[01:28:53.959]   - Field: 'version'
[01:28:53.959]   - Field: 'result'
[01:28:53.960]   - Field: 'asynchronous'
[01:28:53.960]   - Field: 'calls'
[01:28:53.960]   - Field: 'globals'
[01:28:53.960]   - Field: 'stdout'
[01:28:53.960]   - Field: 'earlySignal'
[01:28:53.961]   - Field: 'lazy'
[01:28:53.961]   - Field: 'state'
[01:28:53.961] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:53.961] - Launch lazy future ...
[01:28:53.961] Packages needed by the future expression (n = 0): <none>
[01:28:53.962] Packages needed by future strategies (n = 0): <none>
[01:28:53.962] {
[01:28:53.962]     {
[01:28:53.962]         {
[01:28:53.962]             ...future.startTime <- base::Sys.time()
[01:28:53.962]             {
[01:28:53.962]                 {
[01:28:53.962]                   {
[01:28:53.962]                     base::local({
[01:28:53.962]                       has_future <- base::requireNamespace("future", 
[01:28:53.962]                         quietly = TRUE)
[01:28:53.962]                       if (has_future) {
[01:28:53.962]                         ns <- base::getNamespace("future")
[01:28:53.962]                         version <- ns[[".package"]][["version"]]
[01:28:53.962]                         if (is.null(version)) 
[01:28:53.962]                           version <- utils::packageVersion("future")
[01:28:53.962]                       }
[01:28:53.962]                       else {
[01:28:53.962]                         version <- NULL
[01:28:53.962]                       }
[01:28:53.962]                       if (!has_future || version < "1.8.0") {
[01:28:53.962]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:53.962]                           "", base::R.version$version.string), 
[01:28:53.962]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:53.962]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:53.962]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:53.962]                             "release", "version")], collapse = " "), 
[01:28:53.962]                           hostname = base::Sys.info()[["nodename"]])
[01:28:53.962]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:53.962]                           info)
[01:28:53.962]                         info <- base::paste(info, collapse = "; ")
[01:28:53.962]                         if (!has_future) {
[01:28:53.962]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:53.962]                             info)
[01:28:53.962]                         }
[01:28:53.962]                         else {
[01:28:53.962]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:53.962]                             info, version)
[01:28:53.962]                         }
[01:28:53.962]                         base::stop(msg)
[01:28:53.962]                       }
[01:28:53.962]                     })
[01:28:53.962]                   }
[01:28:53.962]                   options(future.plan = NULL)
[01:28:53.962]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:53.962]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:53.962]                 }
[01:28:53.962]                 ...future.workdir <- getwd()
[01:28:53.962]             }
[01:28:53.962]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:53.962]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:53.962]         }
[01:28:53.962]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:53.962]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:53.962]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:53.962]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:53.962]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:53.962]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:53.962]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:53.962]             base::names(...future.oldOptions))
[01:28:53.962]     }
[01:28:53.962]     if (FALSE) {
[01:28:53.962]     }
[01:28:53.962]     else {
[01:28:53.962]         if (TRUE) {
[01:28:53.962]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:53.962]                 open = "w")
[01:28:53.962]         }
[01:28:53.962]         else {
[01:28:53.962]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:53.962]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:53.962]         }
[01:28:53.962]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:53.962]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:53.962]             base::sink(type = "output", split = FALSE)
[01:28:53.962]             base::close(...future.stdout)
[01:28:53.962]         }, add = TRUE)
[01:28:53.962]     }
[01:28:53.962]     ...future.frame <- base::sys.nframe()
[01:28:53.962]     ...future.conditions <- base::list()
[01:28:53.962]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:53.962]     if (FALSE) {
[01:28:53.962]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:53.962]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:53.962]     }
[01:28:53.962]     ...future.result <- base::tryCatch({
[01:28:53.962]         base::withCallingHandlers({
[01:28:53.962]             ...future.value <- base::withVisible(base::local({
[01:28:53.962]                 Sys.sleep(0.1)
[01:28:53.962]                 kk
[01:28:53.962]             }))
[01:28:53.962]             future::FutureResult(value = ...future.value$value, 
[01:28:53.962]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:53.962]                   ...future.rng), globalenv = if (FALSE) 
[01:28:53.962]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:53.962]                     ...future.globalenv.names))
[01:28:53.962]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:53.962]         }, condition = base::local({
[01:28:53.962]             c <- base::c
[01:28:53.962]             inherits <- base::inherits
[01:28:53.962]             invokeRestart <- base::invokeRestart
[01:28:53.962]             length <- base::length
[01:28:53.962]             list <- base::list
[01:28:53.962]             seq.int <- base::seq.int
[01:28:53.962]             signalCondition <- base::signalCondition
[01:28:53.962]             sys.calls <- base::sys.calls
[01:28:53.962]             `[[` <- base::`[[`
[01:28:53.962]             `+` <- base::`+`
[01:28:53.962]             `<<-` <- base::`<<-`
[01:28:53.962]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:53.962]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:53.962]                   3L)]
[01:28:53.962]             }
[01:28:53.962]             function(cond) {
[01:28:53.962]                 is_error <- inherits(cond, "error")
[01:28:53.962]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:53.962]                   NULL)
[01:28:53.962]                 if (is_error) {
[01:28:53.962]                   sessionInformation <- function() {
[01:28:53.962]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:53.962]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:53.962]                       search = base::search(), system = base::Sys.info())
[01:28:53.962]                   }
[01:28:53.962]                   ...future.conditions[[length(...future.conditions) + 
[01:28:53.962]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:53.962]                     cond$call), session = sessionInformation(), 
[01:28:53.962]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:53.962]                   signalCondition(cond)
[01:28:53.962]                 }
[01:28:53.962]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:53.962]                 "immediateCondition"))) {
[01:28:53.962]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:53.962]                   ...future.conditions[[length(...future.conditions) + 
[01:28:53.962]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:53.962]                   if (TRUE && !signal) {
[01:28:53.962]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:53.962]                     {
[01:28:53.962]                       inherits <- base::inherits
[01:28:53.962]                       invokeRestart <- base::invokeRestart
[01:28:53.962]                       is.null <- base::is.null
[01:28:53.962]                       muffled <- FALSE
[01:28:53.962]                       if (inherits(cond, "message")) {
[01:28:53.962]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:53.962]                         if (muffled) 
[01:28:53.962]                           invokeRestart("muffleMessage")
[01:28:53.962]                       }
[01:28:53.962]                       else if (inherits(cond, "warning")) {
[01:28:53.962]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:53.962]                         if (muffled) 
[01:28:53.962]                           invokeRestart("muffleWarning")
[01:28:53.962]                       }
[01:28:53.962]                       else if (inherits(cond, "condition")) {
[01:28:53.962]                         if (!is.null(pattern)) {
[01:28:53.962]                           computeRestarts <- base::computeRestarts
[01:28:53.962]                           grepl <- base::grepl
[01:28:53.962]                           restarts <- computeRestarts(cond)
[01:28:53.962]                           for (restart in restarts) {
[01:28:53.962]                             name <- restart$name
[01:28:53.962]                             if (is.null(name)) 
[01:28:53.962]                               next
[01:28:53.962]                             if (!grepl(pattern, name)) 
[01:28:53.962]                               next
[01:28:53.962]                             invokeRestart(restart)
[01:28:53.962]                             muffled <- TRUE
[01:28:53.962]                             break
[01:28:53.962]                           }
[01:28:53.962]                         }
[01:28:53.962]                       }
[01:28:53.962]                       invisible(muffled)
[01:28:53.962]                     }
[01:28:53.962]                     muffleCondition(cond, pattern = "^muffle")
[01:28:53.962]                   }
[01:28:53.962]                 }
[01:28:53.962]                 else {
[01:28:53.962]                   if (TRUE) {
[01:28:53.962]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:53.962]                     {
[01:28:53.962]                       inherits <- base::inherits
[01:28:53.962]                       invokeRestart <- base::invokeRestart
[01:28:53.962]                       is.null <- base::is.null
[01:28:53.962]                       muffled <- FALSE
[01:28:53.962]                       if (inherits(cond, "message")) {
[01:28:53.962]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:53.962]                         if (muffled) 
[01:28:53.962]                           invokeRestart("muffleMessage")
[01:28:53.962]                       }
[01:28:53.962]                       else if (inherits(cond, "warning")) {
[01:28:53.962]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:53.962]                         if (muffled) 
[01:28:53.962]                           invokeRestart("muffleWarning")
[01:28:53.962]                       }
[01:28:53.962]                       else if (inherits(cond, "condition")) {
[01:28:53.962]                         if (!is.null(pattern)) {
[01:28:53.962]                           computeRestarts <- base::computeRestarts
[01:28:53.962]                           grepl <- base::grepl
[01:28:53.962]                           restarts <- computeRestarts(cond)
[01:28:53.962]                           for (restart in restarts) {
[01:28:53.962]                             name <- restart$name
[01:28:53.962]                             if (is.null(name)) 
[01:28:53.962]                               next
[01:28:53.962]                             if (!grepl(pattern, name)) 
[01:28:53.962]                               next
[01:28:53.962]                             invokeRestart(restart)
[01:28:53.962]                             muffled <- TRUE
[01:28:53.962]                             break
[01:28:53.962]                           }
[01:28:53.962]                         }
[01:28:53.962]                       }
[01:28:53.962]                       invisible(muffled)
[01:28:53.962]                     }
[01:28:53.962]                     muffleCondition(cond, pattern = "^muffle")
[01:28:53.962]                   }
[01:28:53.962]                 }
[01:28:53.962]             }
[01:28:53.962]         }))
[01:28:53.962]     }, error = function(ex) {
[01:28:53.962]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:53.962]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:53.962]                 ...future.rng), started = ...future.startTime, 
[01:28:53.962]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:53.962]             version = "1.8"), class = "FutureResult")
[01:28:53.962]     }, finally = {
[01:28:53.962]         if (!identical(...future.workdir, getwd())) 
[01:28:53.962]             setwd(...future.workdir)
[01:28:53.962]         {
[01:28:53.962]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:53.962]                 ...future.oldOptions$nwarnings <- NULL
[01:28:53.962]             }
[01:28:53.962]             base::options(...future.oldOptions)
[01:28:53.962]             if (.Platform$OS.type == "windows") {
[01:28:53.962]                 old_names <- names(...future.oldEnvVars)
[01:28:53.962]                 envs <- base::Sys.getenv()
[01:28:53.962]                 names <- names(envs)
[01:28:53.962]                 common <- intersect(names, old_names)
[01:28:53.962]                 added <- setdiff(names, old_names)
[01:28:53.962]                 removed <- setdiff(old_names, names)
[01:28:53.962]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:53.962]                   envs[common]]
[01:28:53.962]                 NAMES <- toupper(changed)
[01:28:53.962]                 args <- list()
[01:28:53.962]                 for (kk in seq_along(NAMES)) {
[01:28:53.962]                   name <- changed[[kk]]
[01:28:53.962]                   NAME <- NAMES[[kk]]
[01:28:53.962]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:53.962]                     next
[01:28:53.962]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:53.962]                 }
[01:28:53.962]                 NAMES <- toupper(added)
[01:28:53.962]                 for (kk in seq_along(NAMES)) {
[01:28:53.962]                   name <- added[[kk]]
[01:28:53.962]                   NAME <- NAMES[[kk]]
[01:28:53.962]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:53.962]                     next
[01:28:53.962]                   args[[name]] <- ""
[01:28:53.962]                 }
[01:28:53.962]                 NAMES <- toupper(removed)
[01:28:53.962]                 for (kk in seq_along(NAMES)) {
[01:28:53.962]                   name <- removed[[kk]]
[01:28:53.962]                   NAME <- NAMES[[kk]]
[01:28:53.962]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:53.962]                     next
[01:28:53.962]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:53.962]                 }
[01:28:53.962]                 if (length(args) > 0) 
[01:28:53.962]                   base::do.call(base::Sys.setenv, args = args)
[01:28:53.962]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:53.962]             }
[01:28:53.962]             else {
[01:28:53.962]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:53.962]             }
[01:28:53.962]             {
[01:28:53.962]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:53.962]                   0L) {
[01:28:53.962]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:53.962]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:53.962]                   base::options(opts)
[01:28:53.962]                 }
[01:28:53.962]                 {
[01:28:53.962]                   {
[01:28:53.962]                     NULL
[01:28:53.962]                     RNGkind("Mersenne-Twister")
[01:28:53.962]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:53.962]                       inherits = FALSE)
[01:28:53.962]                   }
[01:28:53.962]                   options(future.plan = NULL)
[01:28:53.962]                   if (is.na(NA_character_)) 
[01:28:53.962]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:53.962]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:53.962]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:53.962]                   {
[01:28:53.962]                     future <- SequentialFuture(..., envir = envir)
[01:28:53.962]                     if (!future$lazy) 
[01:28:53.962]                       future <- run(future)
[01:28:53.962]                     invisible(future)
[01:28:53.962]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:53.962]                 }
[01:28:53.962]             }
[01:28:53.962]         }
[01:28:53.962]     })
[01:28:53.962]     if (TRUE) {
[01:28:53.962]         base::sink(type = "output", split = FALSE)
[01:28:53.962]         if (TRUE) {
[01:28:53.962]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:53.962]         }
[01:28:53.962]         else {
[01:28:53.962]             ...future.result["stdout"] <- base::list(NULL)
[01:28:53.962]         }
[01:28:53.962]         base::close(...future.stdout)
[01:28:53.962]         ...future.stdout <- NULL
[01:28:53.962]     }
[01:28:53.962]     ...future.result$conditions <- ...future.conditions
[01:28:53.962]     ...future.result$finished <- base::Sys.time()
[01:28:53.962]     ...future.result
[01:28:53.962] }
[01:28:53.966] assign_globals() ...
[01:28:53.966] List of 1
[01:28:53.966]  $ kk: int 1
[01:28:53.966]  - attr(*, "where")=List of 1
[01:28:53.966]   ..$ kk:<environment: R_EmptyEnv> 
[01:28:53.966]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:53.966]  - attr(*, "resolved")= logi FALSE
[01:28:53.966]  - attr(*, "total_size")= num 56
[01:28:53.966]  - attr(*, "already-done")= logi TRUE
[01:28:53.971] - copied 'kk' to environment
[01:28:53.971] assign_globals() ... done
[01:28:53.972] plan(): Setting new future strategy stack:
[01:28:53.972] List of future strategies:
[01:28:53.972] 1. sequential:
[01:28:53.972]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:53.972]    - tweaked: FALSE
[01:28:53.972]    - call: NULL
[01:28:53.972] plan(): nbrOfWorkers() = 1
[01:28:54.077] plan(): Setting new future strategy stack:
[01:28:54.078] List of future strategies:
[01:28:54.078] 1. sequential:
[01:28:54.078]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:54.078]    - tweaked: FALSE
[01:28:54.078]    - call: plan(strategy)
[01:28:54.079] plan(): nbrOfWorkers() = 1
[01:28:54.079] SequentialFuture started (and completed)
[01:28:54.079] - Launch lazy future ... done
[01:28:54.080] run() for 'SequentialFuture' ... done
[01:28:54.080] resolved() for 'SequentialFuture' ...
[01:28:54.080] - state: 'finished'
[01:28:54.081] - run: TRUE
[01:28:54.081] - result: 'FutureResult'
[01:28:54.081] resolved() for 'SequentialFuture' ... done
[01:28:54.081] Future #1
[01:28:54.082]  length: 2 (resolved future 1)
[01:28:54.082] run() for 'Future' ...
[01:28:54.082] - state: 'created'
[01:28:54.082] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:54.083] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:54.083] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:54.084]   - Field: 'label'
[01:28:54.084]   - Field: 'local'
[01:28:54.084]   - Field: 'owner'
[01:28:54.085]   - Field: 'envir'
[01:28:54.085]   - Field: 'packages'
[01:28:54.085]   - Field: 'gc'
[01:28:54.086]   - Field: 'conditions'
[01:28:54.086]   - Field: 'expr'
[01:28:54.086]   - Field: 'uuid'
[01:28:54.086]   - Field: 'seed'
[01:28:54.087]   - Field: 'version'
[01:28:54.087]   - Field: 'result'
[01:28:54.087]   - Field: 'asynchronous'
[01:28:54.088]   - Field: 'calls'
[01:28:54.088]   - Field: 'globals'
[01:28:54.088]   - Field: 'stdout'
[01:28:54.088]   - Field: 'earlySignal'
[01:28:54.089]   - Field: 'lazy'
[01:28:54.089]   - Field: 'state'
[01:28:54.089] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:54.089] - Launch lazy future ...
[01:28:54.090] Packages needed by the future expression (n = 0): <none>
[01:28:54.090] Packages needed by future strategies (n = 0): <none>
[01:28:54.091] {
[01:28:54.091]     {
[01:28:54.091]         {
[01:28:54.091]             ...future.startTime <- base::Sys.time()
[01:28:54.091]             {
[01:28:54.091]                 {
[01:28:54.091]                   {
[01:28:54.091]                     base::local({
[01:28:54.091]                       has_future <- base::requireNamespace("future", 
[01:28:54.091]                         quietly = TRUE)
[01:28:54.091]                       if (has_future) {
[01:28:54.091]                         ns <- base::getNamespace("future")
[01:28:54.091]                         version <- ns[[".package"]][["version"]]
[01:28:54.091]                         if (is.null(version)) 
[01:28:54.091]                           version <- utils::packageVersion("future")
[01:28:54.091]                       }
[01:28:54.091]                       else {
[01:28:54.091]                         version <- NULL
[01:28:54.091]                       }
[01:28:54.091]                       if (!has_future || version < "1.8.0") {
[01:28:54.091]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:54.091]                           "", base::R.version$version.string), 
[01:28:54.091]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:54.091]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:54.091]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:54.091]                             "release", "version")], collapse = " "), 
[01:28:54.091]                           hostname = base::Sys.info()[["nodename"]])
[01:28:54.091]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:54.091]                           info)
[01:28:54.091]                         info <- base::paste(info, collapse = "; ")
[01:28:54.091]                         if (!has_future) {
[01:28:54.091]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:54.091]                             info)
[01:28:54.091]                         }
[01:28:54.091]                         else {
[01:28:54.091]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:54.091]                             info, version)
[01:28:54.091]                         }
[01:28:54.091]                         base::stop(msg)
[01:28:54.091]                       }
[01:28:54.091]                     })
[01:28:54.091]                   }
[01:28:54.091]                   options(future.plan = NULL)
[01:28:54.091]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:54.091]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:54.091]                 }
[01:28:54.091]                 ...future.workdir <- getwd()
[01:28:54.091]             }
[01:28:54.091]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:54.091]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:54.091]         }
[01:28:54.091]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:54.091]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:54.091]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:54.091]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:54.091]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:54.091]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:54.091]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:54.091]             base::names(...future.oldOptions))
[01:28:54.091]     }
[01:28:54.091]     if (FALSE) {
[01:28:54.091]     }
[01:28:54.091]     else {
[01:28:54.091]         if (TRUE) {
[01:28:54.091]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:54.091]                 open = "w")
[01:28:54.091]         }
[01:28:54.091]         else {
[01:28:54.091]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:54.091]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:54.091]         }
[01:28:54.091]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:54.091]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:54.091]             base::sink(type = "output", split = FALSE)
[01:28:54.091]             base::close(...future.stdout)
[01:28:54.091]         }, add = TRUE)
[01:28:54.091]     }
[01:28:54.091]     ...future.frame <- base::sys.nframe()
[01:28:54.091]     ...future.conditions <- base::list()
[01:28:54.091]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:54.091]     if (FALSE) {
[01:28:54.091]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:54.091]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:54.091]     }
[01:28:54.091]     ...future.result <- base::tryCatch({
[01:28:54.091]         base::withCallingHandlers({
[01:28:54.091]             ...future.value <- base::withVisible(base::local({
[01:28:54.091]                 Sys.sleep(0.1)
[01:28:54.091]                 kk
[01:28:54.091]             }))
[01:28:54.091]             future::FutureResult(value = ...future.value$value, 
[01:28:54.091]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:54.091]                   ...future.rng), globalenv = if (FALSE) 
[01:28:54.091]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:54.091]                     ...future.globalenv.names))
[01:28:54.091]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:54.091]         }, condition = base::local({
[01:28:54.091]             c <- base::c
[01:28:54.091]             inherits <- base::inherits
[01:28:54.091]             invokeRestart <- base::invokeRestart
[01:28:54.091]             length <- base::length
[01:28:54.091]             list <- base::list
[01:28:54.091]             seq.int <- base::seq.int
[01:28:54.091]             signalCondition <- base::signalCondition
[01:28:54.091]             sys.calls <- base::sys.calls
[01:28:54.091]             `[[` <- base::`[[`
[01:28:54.091]             `+` <- base::`+`
[01:28:54.091]             `<<-` <- base::`<<-`
[01:28:54.091]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:54.091]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:54.091]                   3L)]
[01:28:54.091]             }
[01:28:54.091]             function(cond) {
[01:28:54.091]                 is_error <- inherits(cond, "error")
[01:28:54.091]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:54.091]                   NULL)
[01:28:54.091]                 if (is_error) {
[01:28:54.091]                   sessionInformation <- function() {
[01:28:54.091]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:54.091]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:54.091]                       search = base::search(), system = base::Sys.info())
[01:28:54.091]                   }
[01:28:54.091]                   ...future.conditions[[length(...future.conditions) + 
[01:28:54.091]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:54.091]                     cond$call), session = sessionInformation(), 
[01:28:54.091]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:54.091]                   signalCondition(cond)
[01:28:54.091]                 }
[01:28:54.091]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:54.091]                 "immediateCondition"))) {
[01:28:54.091]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:54.091]                   ...future.conditions[[length(...future.conditions) + 
[01:28:54.091]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:54.091]                   if (TRUE && !signal) {
[01:28:54.091]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:54.091]                     {
[01:28:54.091]                       inherits <- base::inherits
[01:28:54.091]                       invokeRestart <- base::invokeRestart
[01:28:54.091]                       is.null <- base::is.null
[01:28:54.091]                       muffled <- FALSE
[01:28:54.091]                       if (inherits(cond, "message")) {
[01:28:54.091]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:54.091]                         if (muffled) 
[01:28:54.091]                           invokeRestart("muffleMessage")
[01:28:54.091]                       }
[01:28:54.091]                       else if (inherits(cond, "warning")) {
[01:28:54.091]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:54.091]                         if (muffled) 
[01:28:54.091]                           invokeRestart("muffleWarning")
[01:28:54.091]                       }
[01:28:54.091]                       else if (inherits(cond, "condition")) {
[01:28:54.091]                         if (!is.null(pattern)) {
[01:28:54.091]                           computeRestarts <- base::computeRestarts
[01:28:54.091]                           grepl <- base::grepl
[01:28:54.091]                           restarts <- computeRestarts(cond)
[01:28:54.091]                           for (restart in restarts) {
[01:28:54.091]                             name <- restart$name
[01:28:54.091]                             if (is.null(name)) 
[01:28:54.091]                               next
[01:28:54.091]                             if (!grepl(pattern, name)) 
[01:28:54.091]                               next
[01:28:54.091]                             invokeRestart(restart)
[01:28:54.091]                             muffled <- TRUE
[01:28:54.091]                             break
[01:28:54.091]                           }
[01:28:54.091]                         }
[01:28:54.091]                       }
[01:28:54.091]                       invisible(muffled)
[01:28:54.091]                     }
[01:28:54.091]                     muffleCondition(cond, pattern = "^muffle")
[01:28:54.091]                   }
[01:28:54.091]                 }
[01:28:54.091]                 else {
[01:28:54.091]                   if (TRUE) {
[01:28:54.091]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:54.091]                     {
[01:28:54.091]                       inherits <- base::inherits
[01:28:54.091]                       invokeRestart <- base::invokeRestart
[01:28:54.091]                       is.null <- base::is.null
[01:28:54.091]                       muffled <- FALSE
[01:28:54.091]                       if (inherits(cond, "message")) {
[01:28:54.091]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:54.091]                         if (muffled) 
[01:28:54.091]                           invokeRestart("muffleMessage")
[01:28:54.091]                       }
[01:28:54.091]                       else if (inherits(cond, "warning")) {
[01:28:54.091]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:54.091]                         if (muffled) 
[01:28:54.091]                           invokeRestart("muffleWarning")
[01:28:54.091]                       }
[01:28:54.091]                       else if (inherits(cond, "condition")) {
[01:28:54.091]                         if (!is.null(pattern)) {
[01:28:54.091]                           computeRestarts <- base::computeRestarts
[01:28:54.091]                           grepl <- base::grepl
[01:28:54.091]                           restarts <- computeRestarts(cond)
[01:28:54.091]                           for (restart in restarts) {
[01:28:54.091]                             name <- restart$name
[01:28:54.091]                             if (is.null(name)) 
[01:28:54.091]                               next
[01:28:54.091]                             if (!grepl(pattern, name)) 
[01:28:54.091]                               next
[01:28:54.091]                             invokeRestart(restart)
[01:28:54.091]                             muffled <- TRUE
[01:28:54.091]                             break
[01:28:54.091]                           }
[01:28:54.091]                         }
[01:28:54.091]                       }
[01:28:54.091]                       invisible(muffled)
[01:28:54.091]                     }
[01:28:54.091]                     muffleCondition(cond, pattern = "^muffle")
[01:28:54.091]                   }
[01:28:54.091]                 }
[01:28:54.091]             }
[01:28:54.091]         }))
[01:28:54.091]     }, error = function(ex) {
[01:28:54.091]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:54.091]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:54.091]                 ...future.rng), started = ...future.startTime, 
[01:28:54.091]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:54.091]             version = "1.8"), class = "FutureResult")
[01:28:54.091]     }, finally = {
[01:28:54.091]         if (!identical(...future.workdir, getwd())) 
[01:28:54.091]             setwd(...future.workdir)
[01:28:54.091]         {
[01:28:54.091]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:54.091]                 ...future.oldOptions$nwarnings <- NULL
[01:28:54.091]             }
[01:28:54.091]             base::options(...future.oldOptions)
[01:28:54.091]             if (.Platform$OS.type == "windows") {
[01:28:54.091]                 old_names <- names(...future.oldEnvVars)
[01:28:54.091]                 envs <- base::Sys.getenv()
[01:28:54.091]                 names <- names(envs)
[01:28:54.091]                 common <- intersect(names, old_names)
[01:28:54.091]                 added <- setdiff(names, old_names)
[01:28:54.091]                 removed <- setdiff(old_names, names)
[01:28:54.091]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:54.091]                   envs[common]]
[01:28:54.091]                 NAMES <- toupper(changed)
[01:28:54.091]                 args <- list()
[01:28:54.091]                 for (kk in seq_along(NAMES)) {
[01:28:54.091]                   name <- changed[[kk]]
[01:28:54.091]                   NAME <- NAMES[[kk]]
[01:28:54.091]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.091]                     next
[01:28:54.091]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:54.091]                 }
[01:28:54.091]                 NAMES <- toupper(added)
[01:28:54.091]                 for (kk in seq_along(NAMES)) {
[01:28:54.091]                   name <- added[[kk]]
[01:28:54.091]                   NAME <- NAMES[[kk]]
[01:28:54.091]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.091]                     next
[01:28:54.091]                   args[[name]] <- ""
[01:28:54.091]                 }
[01:28:54.091]                 NAMES <- toupper(removed)
[01:28:54.091]                 for (kk in seq_along(NAMES)) {
[01:28:54.091]                   name <- removed[[kk]]
[01:28:54.091]                   NAME <- NAMES[[kk]]
[01:28:54.091]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.091]                     next
[01:28:54.091]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:54.091]                 }
[01:28:54.091]                 if (length(args) > 0) 
[01:28:54.091]                   base::do.call(base::Sys.setenv, args = args)
[01:28:54.091]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:54.091]             }
[01:28:54.091]             else {
[01:28:54.091]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:54.091]             }
[01:28:54.091]             {
[01:28:54.091]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:54.091]                   0L) {
[01:28:54.091]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:54.091]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:54.091]                   base::options(opts)
[01:28:54.091]                 }
[01:28:54.091]                 {
[01:28:54.091]                   {
[01:28:54.091]                     NULL
[01:28:54.091]                     RNGkind("Mersenne-Twister")
[01:28:54.091]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:54.091]                       inherits = FALSE)
[01:28:54.091]                   }
[01:28:54.091]                   options(future.plan = NULL)
[01:28:54.091]                   if (is.na(NA_character_)) 
[01:28:54.091]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:54.091]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:54.091]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:54.091]                   {
[01:28:54.091]                     future <- SequentialFuture(..., envir = envir)
[01:28:54.091]                     if (!future$lazy) 
[01:28:54.091]                       future <- run(future)
[01:28:54.091]                     invisible(future)
[01:28:54.091]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:54.091]                 }
[01:28:54.091]             }
[01:28:54.091]         }
[01:28:54.091]     })
[01:28:54.091]     if (TRUE) {
[01:28:54.091]         base::sink(type = "output", split = FALSE)
[01:28:54.091]         if (TRUE) {
[01:28:54.091]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:54.091]         }
[01:28:54.091]         else {
[01:28:54.091]             ...future.result["stdout"] <- base::list(NULL)
[01:28:54.091]         }
[01:28:54.091]         base::close(...future.stdout)
[01:28:54.091]         ...future.stdout <- NULL
[01:28:54.091]     }
[01:28:54.091]     ...future.result$conditions <- ...future.conditions
[01:28:54.091]     ...future.result$finished <- base::Sys.time()
[01:28:54.091]     ...future.result
[01:28:54.091] }
[01:28:54.097] assign_globals() ...
[01:28:54.097] List of 1
[01:28:54.097]  $ kk: int 2
[01:28:54.097]  - attr(*, "where")=List of 1
[01:28:54.097]   ..$ kk:<environment: R_EmptyEnv> 
[01:28:54.097]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:54.097]  - attr(*, "resolved")= logi FALSE
[01:28:54.097]  - attr(*, "total_size")= num 56
[01:28:54.097]  - attr(*, "already-done")= logi TRUE
[01:28:54.101] - copied 'kk' to environment
[01:28:54.101] assign_globals() ... done
[01:28:54.102] plan(): Setting new future strategy stack:
[01:28:54.102] List of future strategies:
[01:28:54.102] 1. sequential:
[01:28:54.102]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:54.102]    - tweaked: FALSE
[01:28:54.102]    - call: NULL
[01:28:54.103] plan(): nbrOfWorkers() = 1
[01:28:54.219] plan(): Setting new future strategy stack:
[01:28:54.219] List of future strategies:
[01:28:54.219] 1. sequential:
[01:28:54.219]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:54.219]    - tweaked: FALSE
[01:28:54.219]    - call: plan(strategy)
[01:28:54.220] plan(): nbrOfWorkers() = 1
[01:28:54.221] SequentialFuture started (and completed)
[01:28:54.221] - Launch lazy future ... done
[01:28:54.221] run() for 'SequentialFuture' ... done
[01:28:54.222] resolved() for 'SequentialFuture' ...
[01:28:54.222] - state: 'finished'
[01:28:54.222] - run: TRUE
[01:28:54.223] - result: 'FutureResult'
[01:28:54.223] resolved() for 'SequentialFuture' ... done
[01:28:54.223] Future #2
[01:28:54.223]  length: 1 (resolved future 2)
[01:28:54.224] run() for 'Future' ...
[01:28:54.224] - state: 'created'
[01:28:54.224] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:54.225] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:54.225] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:54.226]   - Field: 'label'
[01:28:54.226]   - Field: 'local'
[01:28:54.226]   - Field: 'owner'
[01:28:54.227]   - Field: 'envir'
[01:28:54.227]   - Field: 'packages'
[01:28:54.227]   - Field: 'gc'
[01:28:54.227]   - Field: 'conditions'
[01:28:54.228]   - Field: 'expr'
[01:28:54.228]   - Field: 'uuid'
[01:28:54.228]   - Field: 'seed'
[01:28:54.229]   - Field: 'version'
[01:28:54.229]   - Field: 'result'
[01:28:54.229]   - Field: 'asynchronous'
[01:28:54.230]   - Field: 'calls'
[01:28:54.230]   - Field: 'globals'
[01:28:54.230]   - Field: 'stdout'
[01:28:54.230]   - Field: 'earlySignal'
[01:28:54.231]   - Field: 'lazy'
[01:28:54.231]   - Field: 'state'
[01:28:54.231] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:54.232] - Launch lazy future ...
[01:28:54.232] Packages needed by the future expression (n = 0): <none>
[01:28:54.232] Packages needed by future strategies (n = 0): <none>
[01:28:54.233] {
[01:28:54.233]     {
[01:28:54.233]         {
[01:28:54.233]             ...future.startTime <- base::Sys.time()
[01:28:54.233]             {
[01:28:54.233]                 {
[01:28:54.233]                   {
[01:28:54.233]                     base::local({
[01:28:54.233]                       has_future <- base::requireNamespace("future", 
[01:28:54.233]                         quietly = TRUE)
[01:28:54.233]                       if (has_future) {
[01:28:54.233]                         ns <- base::getNamespace("future")
[01:28:54.233]                         version <- ns[[".package"]][["version"]]
[01:28:54.233]                         if (is.null(version)) 
[01:28:54.233]                           version <- utils::packageVersion("future")
[01:28:54.233]                       }
[01:28:54.233]                       else {
[01:28:54.233]                         version <- NULL
[01:28:54.233]                       }
[01:28:54.233]                       if (!has_future || version < "1.8.0") {
[01:28:54.233]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:54.233]                           "", base::R.version$version.string), 
[01:28:54.233]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:54.233]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:54.233]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:54.233]                             "release", "version")], collapse = " "), 
[01:28:54.233]                           hostname = base::Sys.info()[["nodename"]])
[01:28:54.233]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:54.233]                           info)
[01:28:54.233]                         info <- base::paste(info, collapse = "; ")
[01:28:54.233]                         if (!has_future) {
[01:28:54.233]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:54.233]                             info)
[01:28:54.233]                         }
[01:28:54.233]                         else {
[01:28:54.233]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:54.233]                             info, version)
[01:28:54.233]                         }
[01:28:54.233]                         base::stop(msg)
[01:28:54.233]                       }
[01:28:54.233]                     })
[01:28:54.233]                   }
[01:28:54.233]                   options(future.plan = NULL)
[01:28:54.233]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:54.233]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:54.233]                 }
[01:28:54.233]                 ...future.workdir <- getwd()
[01:28:54.233]             }
[01:28:54.233]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:54.233]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:54.233]         }
[01:28:54.233]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:54.233]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:54.233]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:54.233]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:54.233]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:54.233]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:54.233]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:54.233]             base::names(...future.oldOptions))
[01:28:54.233]     }
[01:28:54.233]     if (FALSE) {
[01:28:54.233]     }
[01:28:54.233]     else {
[01:28:54.233]         if (TRUE) {
[01:28:54.233]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:54.233]                 open = "w")
[01:28:54.233]         }
[01:28:54.233]         else {
[01:28:54.233]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:54.233]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:54.233]         }
[01:28:54.233]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:54.233]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:54.233]             base::sink(type = "output", split = FALSE)
[01:28:54.233]             base::close(...future.stdout)
[01:28:54.233]         }, add = TRUE)
[01:28:54.233]     }
[01:28:54.233]     ...future.frame <- base::sys.nframe()
[01:28:54.233]     ...future.conditions <- base::list()
[01:28:54.233]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:54.233]     if (FALSE) {
[01:28:54.233]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:54.233]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:54.233]     }
[01:28:54.233]     ...future.result <- base::tryCatch({
[01:28:54.233]         base::withCallingHandlers({
[01:28:54.233]             ...future.value <- base::withVisible(base::local({
[01:28:54.233]                 Sys.sleep(0.1)
[01:28:54.233]                 kk
[01:28:54.233]             }))
[01:28:54.233]             future::FutureResult(value = ...future.value$value, 
[01:28:54.233]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:54.233]                   ...future.rng), globalenv = if (FALSE) 
[01:28:54.233]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:54.233]                     ...future.globalenv.names))
[01:28:54.233]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:54.233]         }, condition = base::local({
[01:28:54.233]             c <- base::c
[01:28:54.233]             inherits <- base::inherits
[01:28:54.233]             invokeRestart <- base::invokeRestart
[01:28:54.233]             length <- base::length
[01:28:54.233]             list <- base::list
[01:28:54.233]             seq.int <- base::seq.int
[01:28:54.233]             signalCondition <- base::signalCondition
[01:28:54.233]             sys.calls <- base::sys.calls
[01:28:54.233]             `[[` <- base::`[[`
[01:28:54.233]             `+` <- base::`+`
[01:28:54.233]             `<<-` <- base::`<<-`
[01:28:54.233]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:54.233]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:54.233]                   3L)]
[01:28:54.233]             }
[01:28:54.233]             function(cond) {
[01:28:54.233]                 is_error <- inherits(cond, "error")
[01:28:54.233]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:54.233]                   NULL)
[01:28:54.233]                 if (is_error) {
[01:28:54.233]                   sessionInformation <- function() {
[01:28:54.233]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:54.233]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:54.233]                       search = base::search(), system = base::Sys.info())
[01:28:54.233]                   }
[01:28:54.233]                   ...future.conditions[[length(...future.conditions) + 
[01:28:54.233]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:54.233]                     cond$call), session = sessionInformation(), 
[01:28:54.233]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:54.233]                   signalCondition(cond)
[01:28:54.233]                 }
[01:28:54.233]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:54.233]                 "immediateCondition"))) {
[01:28:54.233]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:54.233]                   ...future.conditions[[length(...future.conditions) + 
[01:28:54.233]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:54.233]                   if (TRUE && !signal) {
[01:28:54.233]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:54.233]                     {
[01:28:54.233]                       inherits <- base::inherits
[01:28:54.233]                       invokeRestart <- base::invokeRestart
[01:28:54.233]                       is.null <- base::is.null
[01:28:54.233]                       muffled <- FALSE
[01:28:54.233]                       if (inherits(cond, "message")) {
[01:28:54.233]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:54.233]                         if (muffled) 
[01:28:54.233]                           invokeRestart("muffleMessage")
[01:28:54.233]                       }
[01:28:54.233]                       else if (inherits(cond, "warning")) {
[01:28:54.233]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:54.233]                         if (muffled) 
[01:28:54.233]                           invokeRestart("muffleWarning")
[01:28:54.233]                       }
[01:28:54.233]                       else if (inherits(cond, "condition")) {
[01:28:54.233]                         if (!is.null(pattern)) {
[01:28:54.233]                           computeRestarts <- base::computeRestarts
[01:28:54.233]                           grepl <- base::grepl
[01:28:54.233]                           restarts <- computeRestarts(cond)
[01:28:54.233]                           for (restart in restarts) {
[01:28:54.233]                             name <- restart$name
[01:28:54.233]                             if (is.null(name)) 
[01:28:54.233]                               next
[01:28:54.233]                             if (!grepl(pattern, name)) 
[01:28:54.233]                               next
[01:28:54.233]                             invokeRestart(restart)
[01:28:54.233]                             muffled <- TRUE
[01:28:54.233]                             break
[01:28:54.233]                           }
[01:28:54.233]                         }
[01:28:54.233]                       }
[01:28:54.233]                       invisible(muffled)
[01:28:54.233]                     }
[01:28:54.233]                     muffleCondition(cond, pattern = "^muffle")
[01:28:54.233]                   }
[01:28:54.233]                 }
[01:28:54.233]                 else {
[01:28:54.233]                   if (TRUE) {
[01:28:54.233]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:54.233]                     {
[01:28:54.233]                       inherits <- base::inherits
[01:28:54.233]                       invokeRestart <- base::invokeRestart
[01:28:54.233]                       is.null <- base::is.null
[01:28:54.233]                       muffled <- FALSE
[01:28:54.233]                       if (inherits(cond, "message")) {
[01:28:54.233]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:54.233]                         if (muffled) 
[01:28:54.233]                           invokeRestart("muffleMessage")
[01:28:54.233]                       }
[01:28:54.233]                       else if (inherits(cond, "warning")) {
[01:28:54.233]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:54.233]                         if (muffled) 
[01:28:54.233]                           invokeRestart("muffleWarning")
[01:28:54.233]                       }
[01:28:54.233]                       else if (inherits(cond, "condition")) {
[01:28:54.233]                         if (!is.null(pattern)) {
[01:28:54.233]                           computeRestarts <- base::computeRestarts
[01:28:54.233]                           grepl <- base::grepl
[01:28:54.233]                           restarts <- computeRestarts(cond)
[01:28:54.233]                           for (restart in restarts) {
[01:28:54.233]                             name <- restart$name
[01:28:54.233]                             if (is.null(name)) 
[01:28:54.233]                               next
[01:28:54.233]                             if (!grepl(pattern, name)) 
[01:28:54.233]                               next
[01:28:54.233]                             invokeRestart(restart)
[01:28:54.233]                             muffled <- TRUE
[01:28:54.233]                             break
[01:28:54.233]                           }
[01:28:54.233]                         }
[01:28:54.233]                       }
[01:28:54.233]                       invisible(muffled)
[01:28:54.233]                     }
[01:28:54.233]                     muffleCondition(cond, pattern = "^muffle")
[01:28:54.233]                   }
[01:28:54.233]                 }
[01:28:54.233]             }
[01:28:54.233]         }))
[01:28:54.233]     }, error = function(ex) {
[01:28:54.233]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:54.233]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:54.233]                 ...future.rng), started = ...future.startTime, 
[01:28:54.233]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:54.233]             version = "1.8"), class = "FutureResult")
[01:28:54.233]     }, finally = {
[01:28:54.233]         if (!identical(...future.workdir, getwd())) 
[01:28:54.233]             setwd(...future.workdir)
[01:28:54.233]         {
[01:28:54.233]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:54.233]                 ...future.oldOptions$nwarnings <- NULL
[01:28:54.233]             }
[01:28:54.233]             base::options(...future.oldOptions)
[01:28:54.233]             if (.Platform$OS.type == "windows") {
[01:28:54.233]                 old_names <- names(...future.oldEnvVars)
[01:28:54.233]                 envs <- base::Sys.getenv()
[01:28:54.233]                 names <- names(envs)
[01:28:54.233]                 common <- intersect(names, old_names)
[01:28:54.233]                 added <- setdiff(names, old_names)
[01:28:54.233]                 removed <- setdiff(old_names, names)
[01:28:54.233]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:54.233]                   envs[common]]
[01:28:54.233]                 NAMES <- toupper(changed)
[01:28:54.233]                 args <- list()
[01:28:54.233]                 for (kk in seq_along(NAMES)) {
[01:28:54.233]                   name <- changed[[kk]]
[01:28:54.233]                   NAME <- NAMES[[kk]]
[01:28:54.233]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.233]                     next
[01:28:54.233]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:54.233]                 }
[01:28:54.233]                 NAMES <- toupper(added)
[01:28:54.233]                 for (kk in seq_along(NAMES)) {
[01:28:54.233]                   name <- added[[kk]]
[01:28:54.233]                   NAME <- NAMES[[kk]]
[01:28:54.233]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.233]                     next
[01:28:54.233]                   args[[name]] <- ""
[01:28:54.233]                 }
[01:28:54.233]                 NAMES <- toupper(removed)
[01:28:54.233]                 for (kk in seq_along(NAMES)) {
[01:28:54.233]                   name <- removed[[kk]]
[01:28:54.233]                   NAME <- NAMES[[kk]]
[01:28:54.233]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.233]                     next
[01:28:54.233]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:54.233]                 }
[01:28:54.233]                 if (length(args) > 0) 
[01:28:54.233]                   base::do.call(base::Sys.setenv, args = args)
[01:28:54.233]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:54.233]             }
[01:28:54.233]             else {
[01:28:54.233]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:54.233]             }
[01:28:54.233]             {
[01:28:54.233]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:54.233]                   0L) {
[01:28:54.233]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:54.233]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:54.233]                   base::options(opts)
[01:28:54.233]                 }
[01:28:54.233]                 {
[01:28:54.233]                   {
[01:28:54.233]                     NULL
[01:28:54.233]                     RNGkind("Mersenne-Twister")
[01:28:54.233]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:54.233]                       inherits = FALSE)
[01:28:54.233]                   }
[01:28:54.233]                   options(future.plan = NULL)
[01:28:54.233]                   if (is.na(NA_character_)) 
[01:28:54.233]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:54.233]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:54.233]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:54.233]                   {
[01:28:54.233]                     future <- SequentialFuture(..., envir = envir)
[01:28:54.233]                     if (!future$lazy) 
[01:28:54.233]                       future <- run(future)
[01:28:54.233]                     invisible(future)
[01:28:54.233]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:54.233]                 }
[01:28:54.233]             }
[01:28:54.233]         }
[01:28:54.233]     })
[01:28:54.233]     if (TRUE) {
[01:28:54.233]         base::sink(type = "output", split = FALSE)
[01:28:54.233]         if (TRUE) {
[01:28:54.233]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:54.233]         }
[01:28:54.233]         else {
[01:28:54.233]             ...future.result["stdout"] <- base::list(NULL)
[01:28:54.233]         }
[01:28:54.233]         base::close(...future.stdout)
[01:28:54.233]         ...future.stdout <- NULL
[01:28:54.233]     }
[01:28:54.233]     ...future.result$conditions <- ...future.conditions
[01:28:54.233]     ...future.result$finished <- base::Sys.time()
[01:28:54.233]     ...future.result
[01:28:54.233] }
[01:28:54.239] assign_globals() ...
[01:28:54.240] List of 1
[01:28:54.240]  $ kk: int 3
[01:28:54.240]  - attr(*, "where")=List of 1
[01:28:54.240]   ..$ kk:<environment: R_EmptyEnv> 
[01:28:54.240]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:54.240]  - attr(*, "resolved")= logi FALSE
[01:28:54.240]  - attr(*, "total_size")= num 56
[01:28:54.240]  - attr(*, "already-done")= logi TRUE
[01:28:54.247] - copied 'kk' to environment
[01:28:54.247] assign_globals() ... done
[01:28:54.248] plan(): Setting new future strategy stack:
[01:28:54.248] List of future strategies:
[01:28:54.248] 1. sequential:
[01:28:54.248]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:54.248]    - tweaked: FALSE
[01:28:54.248]    - call: NULL
[01:28:54.249] plan(): nbrOfWorkers() = 1
[01:28:54.359] plan(): Setting new future strategy stack:
[01:28:54.359] List of future strategies:
[01:28:54.359] 1. sequential:
[01:28:54.359]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:54.359]    - tweaked: FALSE
[01:28:54.359]    - call: plan(strategy)
[01:28:54.360] plan(): nbrOfWorkers() = 1
[01:28:54.360] SequentialFuture started (and completed)
[01:28:54.360] - Launch lazy future ... done
[01:28:54.360] run() for 'SequentialFuture' ... done
[01:28:54.361] resolved() for 'SequentialFuture' ...
[01:28:54.361] - state: 'finished'
[01:28:54.361] - run: TRUE
[01:28:54.361] - result: 'FutureResult'
[01:28:54.361] resolved() for 'SequentialFuture' ... done
[01:28:54.362] Future #3
[01:28:54.362]  length: 0 (resolved future 3)
[01:28:54.362] resolve() on list ... DONE
*** resolve() for lists ... DONE
*** resolve() for environments ...
[01:28:54.363] resolve() on environment ...
[01:28:54.363]  recursive: 0
[01:28:54.365]  elements: [2] 'a', 'b'
[01:28:54.365]  length: 1 (resolved future 1)
[01:28:54.365]  length: 0 (resolved future 2)
[01:28:54.365] resolve() on environment ... DONE
[01:28:54.366] getGlobalsAndPackages() ...
[01:28:54.366] Searching for globals...
[01:28:54.366] 
[01:28:54.366] Searching for globals ... DONE
[01:28:54.367] - globals: [0] <none>
[01:28:54.367] getGlobalsAndPackages() ... DONE
[01:28:54.367] run() for 'Future' ...
[01:28:54.367] - state: 'created'
[01:28:54.367] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:54.368] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:54.368] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:54.368]   - Field: 'label'
[01:28:54.368]   - Field: 'local'
[01:28:54.369]   - Field: 'owner'
[01:28:54.369]   - Field: 'envir'
[01:28:54.369]   - Field: 'packages'
[01:28:54.369]   - Field: 'gc'
[01:28:54.369]   - Field: 'conditions'
[01:28:54.369]   - Field: 'expr'
[01:28:54.370]   - Field: 'uuid'
[01:28:54.370]   - Field: 'seed'
[01:28:54.370]   - Field: 'version'
[01:28:54.370]   - Field: 'result'
[01:28:54.370]   - Field: 'asynchronous'
[01:28:54.371]   - Field: 'calls'
[01:28:54.371]   - Field: 'globals'
[01:28:54.371]   - Field: 'stdout'
[01:28:54.371]   - Field: 'earlySignal'
[01:28:54.371]   - Field: 'lazy'
[01:28:54.371]   - Field: 'state'
[01:28:54.372] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:54.372] - Launch lazy future ...
[01:28:54.372] Packages needed by the future expression (n = 0): <none>
[01:28:54.372] Packages needed by future strategies (n = 0): <none>
[01:28:54.373] {
[01:28:54.373]     {
[01:28:54.373]         {
[01:28:54.373]             ...future.startTime <- base::Sys.time()
[01:28:54.373]             {
[01:28:54.373]                 {
[01:28:54.373]                   {
[01:28:54.373]                     base::local({
[01:28:54.373]                       has_future <- base::requireNamespace("future", 
[01:28:54.373]                         quietly = TRUE)
[01:28:54.373]                       if (has_future) {
[01:28:54.373]                         ns <- base::getNamespace("future")
[01:28:54.373]                         version <- ns[[".package"]][["version"]]
[01:28:54.373]                         if (is.null(version)) 
[01:28:54.373]                           version <- utils::packageVersion("future")
[01:28:54.373]                       }
[01:28:54.373]                       else {
[01:28:54.373]                         version <- NULL
[01:28:54.373]                       }
[01:28:54.373]                       if (!has_future || version < "1.8.0") {
[01:28:54.373]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:54.373]                           "", base::R.version$version.string), 
[01:28:54.373]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:54.373]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:54.373]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:54.373]                             "release", "version")], collapse = " "), 
[01:28:54.373]                           hostname = base::Sys.info()[["nodename"]])
[01:28:54.373]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:54.373]                           info)
[01:28:54.373]                         info <- base::paste(info, collapse = "; ")
[01:28:54.373]                         if (!has_future) {
[01:28:54.373]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:54.373]                             info)
[01:28:54.373]                         }
[01:28:54.373]                         else {
[01:28:54.373]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:54.373]                             info, version)
[01:28:54.373]                         }
[01:28:54.373]                         base::stop(msg)
[01:28:54.373]                       }
[01:28:54.373]                     })
[01:28:54.373]                   }
[01:28:54.373]                   options(future.plan = NULL)
[01:28:54.373]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:54.373]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:54.373]                 }
[01:28:54.373]                 ...future.workdir <- getwd()
[01:28:54.373]             }
[01:28:54.373]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:54.373]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:54.373]         }
[01:28:54.373]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:54.373]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:54.373]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:54.373]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:54.373]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:54.373]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:54.373]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:54.373]             base::names(...future.oldOptions))
[01:28:54.373]     }
[01:28:54.373]     if (FALSE) {
[01:28:54.373]     }
[01:28:54.373]     else {
[01:28:54.373]         if (TRUE) {
[01:28:54.373]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:54.373]                 open = "w")
[01:28:54.373]         }
[01:28:54.373]         else {
[01:28:54.373]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:54.373]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:54.373]         }
[01:28:54.373]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:54.373]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:54.373]             base::sink(type = "output", split = FALSE)
[01:28:54.373]             base::close(...future.stdout)
[01:28:54.373]         }, add = TRUE)
[01:28:54.373]     }
[01:28:54.373]     ...future.frame <- base::sys.nframe()
[01:28:54.373]     ...future.conditions <- base::list()
[01:28:54.373]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:54.373]     if (FALSE) {
[01:28:54.373]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:54.373]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:54.373]     }
[01:28:54.373]     ...future.result <- base::tryCatch({
[01:28:54.373]         base::withCallingHandlers({
[01:28:54.373]             ...future.value <- base::withVisible(base::local(1))
[01:28:54.373]             future::FutureResult(value = ...future.value$value, 
[01:28:54.373]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:54.373]                   ...future.rng), globalenv = if (FALSE) 
[01:28:54.373]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:54.373]                     ...future.globalenv.names))
[01:28:54.373]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:54.373]         }, condition = base::local({
[01:28:54.373]             c <- base::c
[01:28:54.373]             inherits <- base::inherits
[01:28:54.373]             invokeRestart <- base::invokeRestart
[01:28:54.373]             length <- base::length
[01:28:54.373]             list <- base::list
[01:28:54.373]             seq.int <- base::seq.int
[01:28:54.373]             signalCondition <- base::signalCondition
[01:28:54.373]             sys.calls <- base::sys.calls
[01:28:54.373]             `[[` <- base::`[[`
[01:28:54.373]             `+` <- base::`+`
[01:28:54.373]             `<<-` <- base::`<<-`
[01:28:54.373]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:54.373]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:54.373]                   3L)]
[01:28:54.373]             }
[01:28:54.373]             function(cond) {
[01:28:54.373]                 is_error <- inherits(cond, "error")
[01:28:54.373]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:54.373]                   NULL)
[01:28:54.373]                 if (is_error) {
[01:28:54.373]                   sessionInformation <- function() {
[01:28:54.373]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:54.373]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:54.373]                       search = base::search(), system = base::Sys.info())
[01:28:54.373]                   }
[01:28:54.373]                   ...future.conditions[[length(...future.conditions) + 
[01:28:54.373]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:54.373]                     cond$call), session = sessionInformation(), 
[01:28:54.373]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:54.373]                   signalCondition(cond)
[01:28:54.373]                 }
[01:28:54.373]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:54.373]                 "immediateCondition"))) {
[01:28:54.373]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:54.373]                   ...future.conditions[[length(...future.conditions) + 
[01:28:54.373]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:54.373]                   if (TRUE && !signal) {
[01:28:54.373]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:54.373]                     {
[01:28:54.373]                       inherits <- base::inherits
[01:28:54.373]                       invokeRestart <- base::invokeRestart
[01:28:54.373]                       is.null <- base::is.null
[01:28:54.373]                       muffled <- FALSE
[01:28:54.373]                       if (inherits(cond, "message")) {
[01:28:54.373]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:54.373]                         if (muffled) 
[01:28:54.373]                           invokeRestart("muffleMessage")
[01:28:54.373]                       }
[01:28:54.373]                       else if (inherits(cond, "warning")) {
[01:28:54.373]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:54.373]                         if (muffled) 
[01:28:54.373]                           invokeRestart("muffleWarning")
[01:28:54.373]                       }
[01:28:54.373]                       else if (inherits(cond, "condition")) {
[01:28:54.373]                         if (!is.null(pattern)) {
[01:28:54.373]                           computeRestarts <- base::computeRestarts
[01:28:54.373]                           grepl <- base::grepl
[01:28:54.373]                           restarts <- computeRestarts(cond)
[01:28:54.373]                           for (restart in restarts) {
[01:28:54.373]                             name <- restart$name
[01:28:54.373]                             if (is.null(name)) 
[01:28:54.373]                               next
[01:28:54.373]                             if (!grepl(pattern, name)) 
[01:28:54.373]                               next
[01:28:54.373]                             invokeRestart(restart)
[01:28:54.373]                             muffled <- TRUE
[01:28:54.373]                             break
[01:28:54.373]                           }
[01:28:54.373]                         }
[01:28:54.373]                       }
[01:28:54.373]                       invisible(muffled)
[01:28:54.373]                     }
[01:28:54.373]                     muffleCondition(cond, pattern = "^muffle")
[01:28:54.373]                   }
[01:28:54.373]                 }
[01:28:54.373]                 else {
[01:28:54.373]                   if (TRUE) {
[01:28:54.373]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:54.373]                     {
[01:28:54.373]                       inherits <- base::inherits
[01:28:54.373]                       invokeRestart <- base::invokeRestart
[01:28:54.373]                       is.null <- base::is.null
[01:28:54.373]                       muffled <- FALSE
[01:28:54.373]                       if (inherits(cond, "message")) {
[01:28:54.373]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:54.373]                         if (muffled) 
[01:28:54.373]                           invokeRestart("muffleMessage")
[01:28:54.373]                       }
[01:28:54.373]                       else if (inherits(cond, "warning")) {
[01:28:54.373]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:54.373]                         if (muffled) 
[01:28:54.373]                           invokeRestart("muffleWarning")
[01:28:54.373]                       }
[01:28:54.373]                       else if (inherits(cond, "condition")) {
[01:28:54.373]                         if (!is.null(pattern)) {
[01:28:54.373]                           computeRestarts <- base::computeRestarts
[01:28:54.373]                           grepl <- base::grepl
[01:28:54.373]                           restarts <- computeRestarts(cond)
[01:28:54.373]                           for (restart in restarts) {
[01:28:54.373]                             name <- restart$name
[01:28:54.373]                             if (is.null(name)) 
[01:28:54.373]                               next
[01:28:54.373]                             if (!grepl(pattern, name)) 
[01:28:54.373]                               next
[01:28:54.373]                             invokeRestart(restart)
[01:28:54.373]                             muffled <- TRUE
[01:28:54.373]                             break
[01:28:54.373]                           }
[01:28:54.373]                         }
[01:28:54.373]                       }
[01:28:54.373]                       invisible(muffled)
[01:28:54.373]                     }
[01:28:54.373]                     muffleCondition(cond, pattern = "^muffle")
[01:28:54.373]                   }
[01:28:54.373]                 }
[01:28:54.373]             }
[01:28:54.373]         }))
[01:28:54.373]     }, error = function(ex) {
[01:28:54.373]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:54.373]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:54.373]                 ...future.rng), started = ...future.startTime, 
[01:28:54.373]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:54.373]             version = "1.8"), class = "FutureResult")
[01:28:54.373]     }, finally = {
[01:28:54.373]         if (!identical(...future.workdir, getwd())) 
[01:28:54.373]             setwd(...future.workdir)
[01:28:54.373]         {
[01:28:54.373]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:54.373]                 ...future.oldOptions$nwarnings <- NULL
[01:28:54.373]             }
[01:28:54.373]             base::options(...future.oldOptions)
[01:28:54.373]             if (.Platform$OS.type == "windows") {
[01:28:54.373]                 old_names <- names(...future.oldEnvVars)
[01:28:54.373]                 envs <- base::Sys.getenv()
[01:28:54.373]                 names <- names(envs)
[01:28:54.373]                 common <- intersect(names, old_names)
[01:28:54.373]                 added <- setdiff(names, old_names)
[01:28:54.373]                 removed <- setdiff(old_names, names)
[01:28:54.373]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:54.373]                   envs[common]]
[01:28:54.373]                 NAMES <- toupper(changed)
[01:28:54.373]                 args <- list()
[01:28:54.373]                 for (kk in seq_along(NAMES)) {
[01:28:54.373]                   name <- changed[[kk]]
[01:28:54.373]                   NAME <- NAMES[[kk]]
[01:28:54.373]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.373]                     next
[01:28:54.373]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:54.373]                 }
[01:28:54.373]                 NAMES <- toupper(added)
[01:28:54.373]                 for (kk in seq_along(NAMES)) {
[01:28:54.373]                   name <- added[[kk]]
[01:28:54.373]                   NAME <- NAMES[[kk]]
[01:28:54.373]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.373]                     next
[01:28:54.373]                   args[[name]] <- ""
[01:28:54.373]                 }
[01:28:54.373]                 NAMES <- toupper(removed)
[01:28:54.373]                 for (kk in seq_along(NAMES)) {
[01:28:54.373]                   name <- removed[[kk]]
[01:28:54.373]                   NAME <- NAMES[[kk]]
[01:28:54.373]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.373]                     next
[01:28:54.373]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:54.373]                 }
[01:28:54.373]                 if (length(args) > 0) 
[01:28:54.373]                   base::do.call(base::Sys.setenv, args = args)
[01:28:54.373]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:54.373]             }
[01:28:54.373]             else {
[01:28:54.373]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:54.373]             }
[01:28:54.373]             {
[01:28:54.373]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:54.373]                   0L) {
[01:28:54.373]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:54.373]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:54.373]                   base::options(opts)
[01:28:54.373]                 }
[01:28:54.373]                 {
[01:28:54.373]                   {
[01:28:54.373]                     NULL
[01:28:54.373]                     RNGkind("Mersenne-Twister")
[01:28:54.373]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:54.373]                       inherits = FALSE)
[01:28:54.373]                   }
[01:28:54.373]                   options(future.plan = NULL)
[01:28:54.373]                   if (is.na(NA_character_)) 
[01:28:54.373]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:54.373]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:54.373]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:54.373]                   {
[01:28:54.373]                     future <- SequentialFuture(..., envir = envir)
[01:28:54.373]                     if (!future$lazy) 
[01:28:54.373]                       future <- run(future)
[01:28:54.373]                     invisible(future)
[01:28:54.373]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:54.373]                 }
[01:28:54.373]             }
[01:28:54.373]         }
[01:28:54.373]     })
[01:28:54.373]     if (TRUE) {
[01:28:54.373]         base::sink(type = "output", split = FALSE)
[01:28:54.373]         if (TRUE) {
[01:28:54.373]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:54.373]         }
[01:28:54.373]         else {
[01:28:54.373]             ...future.result["stdout"] <- base::list(NULL)
[01:28:54.373]         }
[01:28:54.373]         base::close(...future.stdout)
[01:28:54.373]         ...future.stdout <- NULL
[01:28:54.373]     }
[01:28:54.373]     ...future.result$conditions <- ...future.conditions
[01:28:54.373]     ...future.result$finished <- base::Sys.time()
[01:28:54.373]     ...future.result
[01:28:54.373] }
[01:28:54.377] plan(): Setting new future strategy stack:
[01:28:54.377] List of future strategies:
[01:28:54.377] 1. sequential:
[01:28:54.377]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:54.377]    - tweaked: FALSE
[01:28:54.377]    - call: NULL
[01:28:54.378] plan(): nbrOfWorkers() = 1
[01:28:54.379] plan(): Setting new future strategy stack:
[01:28:54.379] List of future strategies:
[01:28:54.379] 1. sequential:
[01:28:54.379]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:54.379]    - tweaked: FALSE
[01:28:54.379]    - call: plan(strategy)
[01:28:54.380] plan(): nbrOfWorkers() = 1
[01:28:54.380] SequentialFuture started (and completed)
[01:28:54.380] - Launch lazy future ... done
[01:28:54.380] run() for 'SequentialFuture' ... done
[01:28:54.380] getGlobalsAndPackages() ...
[01:28:54.381] Searching for globals...
[01:28:54.381] 
[01:28:54.381] Searching for globals ... DONE
[01:28:54.381] - globals: [0] <none>
[01:28:54.381] getGlobalsAndPackages() ... DONE
[01:28:54.382] run() for 'Future' ...
[01:28:54.382] - state: 'created'
[01:28:54.382] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:54.383] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:54.383] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:54.383]   - Field: 'label'
[01:28:54.383]   - Field: 'local'
[01:28:54.383]   - Field: 'owner'
[01:28:54.383]   - Field: 'envir'
[01:28:54.384]   - Field: 'packages'
[01:28:54.384]   - Field: 'gc'
[01:28:54.384]   - Field: 'conditions'
[01:28:54.384]   - Field: 'expr'
[01:28:54.384]   - Field: 'uuid'
[01:28:54.385]   - Field: 'seed'
[01:28:54.385]   - Field: 'version'
[01:28:54.385]   - Field: 'result'
[01:28:54.385]   - Field: 'asynchronous'
[01:28:54.385]   - Field: 'calls'
[01:28:54.385]   - Field: 'globals'
[01:28:54.386]   - Field: 'stdout'
[01:28:54.386]   - Field: 'earlySignal'
[01:28:54.386]   - Field: 'lazy'
[01:28:54.386]   - Field: 'state'
[01:28:54.386] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:54.386] - Launch lazy future ...
[01:28:54.387] Packages needed by the future expression (n = 0): <none>
[01:28:54.387] Packages needed by future strategies (n = 0): <none>
[01:28:54.387] {
[01:28:54.387]     {
[01:28:54.387]         {
[01:28:54.387]             ...future.startTime <- base::Sys.time()
[01:28:54.387]             {
[01:28:54.387]                 {
[01:28:54.387]                   {
[01:28:54.387]                     base::local({
[01:28:54.387]                       has_future <- base::requireNamespace("future", 
[01:28:54.387]                         quietly = TRUE)
[01:28:54.387]                       if (has_future) {
[01:28:54.387]                         ns <- base::getNamespace("future")
[01:28:54.387]                         version <- ns[[".package"]][["version"]]
[01:28:54.387]                         if (is.null(version)) 
[01:28:54.387]                           version <- utils::packageVersion("future")
[01:28:54.387]                       }
[01:28:54.387]                       else {
[01:28:54.387]                         version <- NULL
[01:28:54.387]                       }
[01:28:54.387]                       if (!has_future || version < "1.8.0") {
[01:28:54.387]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:54.387]                           "", base::R.version$version.string), 
[01:28:54.387]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:54.387]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:54.387]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:54.387]                             "release", "version")], collapse = " "), 
[01:28:54.387]                           hostname = base::Sys.info()[["nodename"]])
[01:28:54.387]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:54.387]                           info)
[01:28:54.387]                         info <- base::paste(info, collapse = "; ")
[01:28:54.387]                         if (!has_future) {
[01:28:54.387]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:54.387]                             info)
[01:28:54.387]                         }
[01:28:54.387]                         else {
[01:28:54.387]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:54.387]                             info, version)
[01:28:54.387]                         }
[01:28:54.387]                         base::stop(msg)
[01:28:54.387]                       }
[01:28:54.387]                     })
[01:28:54.387]                   }
[01:28:54.387]                   options(future.plan = NULL)
[01:28:54.387]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:54.387]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:54.387]                 }
[01:28:54.387]                 ...future.workdir <- getwd()
[01:28:54.387]             }
[01:28:54.387]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:54.387]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:54.387]         }
[01:28:54.387]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:54.387]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:54.387]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:54.387]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:54.387]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:54.387]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:54.387]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:54.387]             base::names(...future.oldOptions))
[01:28:54.387]     }
[01:28:54.387]     if (FALSE) {
[01:28:54.387]     }
[01:28:54.387]     else {
[01:28:54.387]         if (TRUE) {
[01:28:54.387]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:54.387]                 open = "w")
[01:28:54.387]         }
[01:28:54.387]         else {
[01:28:54.387]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:54.387]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:54.387]         }
[01:28:54.387]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:54.387]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:54.387]             base::sink(type = "output", split = FALSE)
[01:28:54.387]             base::close(...future.stdout)
[01:28:54.387]         }, add = TRUE)
[01:28:54.387]     }
[01:28:54.387]     ...future.frame <- base::sys.nframe()
[01:28:54.387]     ...future.conditions <- base::list()
[01:28:54.387]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:54.387]     if (FALSE) {
[01:28:54.387]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:54.387]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:54.387]     }
[01:28:54.387]     ...future.result <- base::tryCatch({
[01:28:54.387]         base::withCallingHandlers({
[01:28:54.387]             ...future.value <- base::withVisible(base::local(2))
[01:28:54.387]             future::FutureResult(value = ...future.value$value, 
[01:28:54.387]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:54.387]                   ...future.rng), globalenv = if (FALSE) 
[01:28:54.387]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:54.387]                     ...future.globalenv.names))
[01:28:54.387]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:54.387]         }, condition = base::local({
[01:28:54.387]             c <- base::c
[01:28:54.387]             inherits <- base::inherits
[01:28:54.387]             invokeRestart <- base::invokeRestart
[01:28:54.387]             length <- base::length
[01:28:54.387]             list <- base::list
[01:28:54.387]             seq.int <- base::seq.int
[01:28:54.387]             signalCondition <- base::signalCondition
[01:28:54.387]             sys.calls <- base::sys.calls
[01:28:54.387]             `[[` <- base::`[[`
[01:28:54.387]             `+` <- base::`+`
[01:28:54.387]             `<<-` <- base::`<<-`
[01:28:54.387]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:54.387]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:54.387]                   3L)]
[01:28:54.387]             }
[01:28:54.387]             function(cond) {
[01:28:54.387]                 is_error <- inherits(cond, "error")
[01:28:54.387]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:54.387]                   NULL)
[01:28:54.387]                 if (is_error) {
[01:28:54.387]                   sessionInformation <- function() {
[01:28:54.387]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:54.387]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:54.387]                       search = base::search(), system = base::Sys.info())
[01:28:54.387]                   }
[01:28:54.387]                   ...future.conditions[[length(...future.conditions) + 
[01:28:54.387]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:54.387]                     cond$call), session = sessionInformation(), 
[01:28:54.387]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:54.387]                   signalCondition(cond)
[01:28:54.387]                 }
[01:28:54.387]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:54.387]                 "immediateCondition"))) {
[01:28:54.387]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:54.387]                   ...future.conditions[[length(...future.conditions) + 
[01:28:54.387]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:54.387]                   if (TRUE && !signal) {
[01:28:54.387]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:54.387]                     {
[01:28:54.387]                       inherits <- base::inherits
[01:28:54.387]                       invokeRestart <- base::invokeRestart
[01:28:54.387]                       is.null <- base::is.null
[01:28:54.387]                       muffled <- FALSE
[01:28:54.387]                       if (inherits(cond, "message")) {
[01:28:54.387]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:54.387]                         if (muffled) 
[01:28:54.387]                           invokeRestart("muffleMessage")
[01:28:54.387]                       }
[01:28:54.387]                       else if (inherits(cond, "warning")) {
[01:28:54.387]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:54.387]                         if (muffled) 
[01:28:54.387]                           invokeRestart("muffleWarning")
[01:28:54.387]                       }
[01:28:54.387]                       else if (inherits(cond, "condition")) {
[01:28:54.387]                         if (!is.null(pattern)) {
[01:28:54.387]                           computeRestarts <- base::computeRestarts
[01:28:54.387]                           grepl <- base::grepl
[01:28:54.387]                           restarts <- computeRestarts(cond)
[01:28:54.387]                           for (restart in restarts) {
[01:28:54.387]                             name <- restart$name
[01:28:54.387]                             if (is.null(name)) 
[01:28:54.387]                               next
[01:28:54.387]                             if (!grepl(pattern, name)) 
[01:28:54.387]                               next
[01:28:54.387]                             invokeRestart(restart)
[01:28:54.387]                             muffled <- TRUE
[01:28:54.387]                             break
[01:28:54.387]                           }
[01:28:54.387]                         }
[01:28:54.387]                       }
[01:28:54.387]                       invisible(muffled)
[01:28:54.387]                     }
[01:28:54.387]                     muffleCondition(cond, pattern = "^muffle")
[01:28:54.387]                   }
[01:28:54.387]                 }
[01:28:54.387]                 else {
[01:28:54.387]                   if (TRUE) {
[01:28:54.387]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:54.387]                     {
[01:28:54.387]                       inherits <- base::inherits
[01:28:54.387]                       invokeRestart <- base::invokeRestart
[01:28:54.387]                       is.null <- base::is.null
[01:28:54.387]                       muffled <- FALSE
[01:28:54.387]                       if (inherits(cond, "message")) {
[01:28:54.387]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:54.387]                         if (muffled) 
[01:28:54.387]                           invokeRestart("muffleMessage")
[01:28:54.387]                       }
[01:28:54.387]                       else if (inherits(cond, "warning")) {
[01:28:54.387]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:54.387]                         if (muffled) 
[01:28:54.387]                           invokeRestart("muffleWarning")
[01:28:54.387]                       }
[01:28:54.387]                       else if (inherits(cond, "condition")) {
[01:28:54.387]                         if (!is.null(pattern)) {
[01:28:54.387]                           computeRestarts <- base::computeRestarts
[01:28:54.387]                           grepl <- base::grepl
[01:28:54.387]                           restarts <- computeRestarts(cond)
[01:28:54.387]                           for (restart in restarts) {
[01:28:54.387]                             name <- restart$name
[01:28:54.387]                             if (is.null(name)) 
[01:28:54.387]                               next
[01:28:54.387]                             if (!grepl(pattern, name)) 
[01:28:54.387]                               next
[01:28:54.387]                             invokeRestart(restart)
[01:28:54.387]                             muffled <- TRUE
[01:28:54.387]                             break
[01:28:54.387]                           }
[01:28:54.387]                         }
[01:28:54.387]                       }
[01:28:54.387]                       invisible(muffled)
[01:28:54.387]                     }
[01:28:54.387]                     muffleCondition(cond, pattern = "^muffle")
[01:28:54.387]                   }
[01:28:54.387]                 }
[01:28:54.387]             }
[01:28:54.387]         }))
[01:28:54.387]     }, error = function(ex) {
[01:28:54.387]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:54.387]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:54.387]                 ...future.rng), started = ...future.startTime, 
[01:28:54.387]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:54.387]             version = "1.8"), class = "FutureResult")
[01:28:54.387]     }, finally = {
[01:28:54.387]         if (!identical(...future.workdir, getwd())) 
[01:28:54.387]             setwd(...future.workdir)
[01:28:54.387]         {
[01:28:54.387]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:54.387]                 ...future.oldOptions$nwarnings <- NULL
[01:28:54.387]             }
[01:28:54.387]             base::options(...future.oldOptions)
[01:28:54.387]             if (.Platform$OS.type == "windows") {
[01:28:54.387]                 old_names <- names(...future.oldEnvVars)
[01:28:54.387]                 envs <- base::Sys.getenv()
[01:28:54.387]                 names <- names(envs)
[01:28:54.387]                 common <- intersect(names, old_names)
[01:28:54.387]                 added <- setdiff(names, old_names)
[01:28:54.387]                 removed <- setdiff(old_names, names)
[01:28:54.387]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:54.387]                   envs[common]]
[01:28:54.387]                 NAMES <- toupper(changed)
[01:28:54.387]                 args <- list()
[01:28:54.387]                 for (kk in seq_along(NAMES)) {
[01:28:54.387]                   name <- changed[[kk]]
[01:28:54.387]                   NAME <- NAMES[[kk]]
[01:28:54.387]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.387]                     next
[01:28:54.387]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:54.387]                 }
[01:28:54.387]                 NAMES <- toupper(added)
[01:28:54.387]                 for (kk in seq_along(NAMES)) {
[01:28:54.387]                   name <- added[[kk]]
[01:28:54.387]                   NAME <- NAMES[[kk]]
[01:28:54.387]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.387]                     next
[01:28:54.387]                   args[[name]] <- ""
[01:28:54.387]                 }
[01:28:54.387]                 NAMES <- toupper(removed)
[01:28:54.387]                 for (kk in seq_along(NAMES)) {
[01:28:54.387]                   name <- removed[[kk]]
[01:28:54.387]                   NAME <- NAMES[[kk]]
[01:28:54.387]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.387]                     next
[01:28:54.387]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:54.387]                 }
[01:28:54.387]                 if (length(args) > 0) 
[01:28:54.387]                   base::do.call(base::Sys.setenv, args = args)
[01:28:54.387]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:54.387]             }
[01:28:54.387]             else {
[01:28:54.387]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:54.387]             }
[01:28:54.387]             {
[01:28:54.387]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:54.387]                   0L) {
[01:28:54.387]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:54.387]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:54.387]                   base::options(opts)
[01:28:54.387]                 }
[01:28:54.387]                 {
[01:28:54.387]                   {
[01:28:54.387]                     NULL
[01:28:54.387]                     RNGkind("Mersenne-Twister")
[01:28:54.387]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:54.387]                       inherits = FALSE)
[01:28:54.387]                   }
[01:28:54.387]                   options(future.plan = NULL)
[01:28:54.387]                   if (is.na(NA_character_)) 
[01:28:54.387]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:54.387]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:54.387]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:54.387]                   {
[01:28:54.387]                     future <- SequentialFuture(..., envir = envir)
[01:28:54.387]                     if (!future$lazy) 
[01:28:54.387]                       future <- run(future)
[01:28:54.387]                     invisible(future)
[01:28:54.387]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:54.387]                 }
[01:28:54.387]             }
[01:28:54.387]         }
[01:28:54.387]     })
[01:28:54.387]     if (TRUE) {
[01:28:54.387]         base::sink(type = "output", split = FALSE)
[01:28:54.387]         if (TRUE) {
[01:28:54.387]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:54.387]         }
[01:28:54.387]         else {
[01:28:54.387]             ...future.result["stdout"] <- base::list(NULL)
[01:28:54.387]         }
[01:28:54.387]         base::close(...future.stdout)
[01:28:54.387]         ...future.stdout <- NULL
[01:28:54.387]     }
[01:28:54.387]     ...future.result$conditions <- ...future.conditions
[01:28:54.387]     ...future.result$finished <- base::Sys.time()
[01:28:54.387]     ...future.result
[01:28:54.387] }
[01:28:54.391] plan(): Setting new future strategy stack:
[01:28:54.392] List of future strategies:
[01:28:54.392] 1. sequential:
[01:28:54.392]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:54.392]    - tweaked: FALSE
[01:28:54.392]    - call: NULL
[01:28:54.392] plan(): nbrOfWorkers() = 1
[01:28:54.393] plan(): Setting new future strategy stack:
[01:28:54.394] List of future strategies:
[01:28:54.394] 1. sequential:
[01:28:54.394]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:54.394]    - tweaked: FALSE
[01:28:54.394]    - call: plan(strategy)
[01:28:54.396] plan(): nbrOfWorkers() = 1
[01:28:54.396] SequentialFuture started (and completed)
[01:28:54.396] - Launch lazy future ... done
[01:28:54.396] run() for 'SequentialFuture' ... done
[01:28:54.397] resolve() on environment ...
[01:28:54.397]  recursive: 0
[01:28:54.398]  elements: [3] 'a', 'b', 'c'
[01:28:54.398] resolved() for 'SequentialFuture' ...
[01:28:54.398] - state: 'finished'
[01:28:54.398] - run: TRUE
[01:28:54.399] - result: 'FutureResult'
[01:28:54.399] resolved() for 'SequentialFuture' ... done
[01:28:54.399] Future #1
[01:28:54.399]  length: 2 (resolved future 1)
[01:28:54.399] resolved() for 'SequentialFuture' ...
[01:28:54.399] - state: 'finished'
[01:28:54.400] - run: TRUE
[01:28:54.400] - result: 'FutureResult'
[01:28:54.400] resolved() for 'SequentialFuture' ... done
[01:28:54.400] Future #2
[01:28:54.400]  length: 1 (resolved future 2)
[01:28:54.401]  length: 0 (resolved future 3)
[01:28:54.401] resolve() on environment ... DONE
[01:28:54.401] resolved() for 'SequentialFuture' ...
[01:28:54.401] - state: 'finished'
[01:28:54.401] - run: TRUE
[01:28:54.401] - result: 'FutureResult'
[01:28:54.402] resolved() for 'SequentialFuture' ... done
[01:28:54.402] resolved() for 'SequentialFuture' ...
[01:28:54.402] - state: 'finished'
[01:28:54.402] - run: TRUE
[01:28:54.402] - result: 'FutureResult'
[01:28:54.402] resolved() for 'SequentialFuture' ... done
[01:28:54.404] getGlobalsAndPackages() ...
[01:28:54.404] Searching for globals...
[01:28:54.405] - globals found: [1] '{'
[01:28:54.405] Searching for globals ... DONE
[01:28:54.405] Resolving globals: FALSE
[01:28:54.406] 
[01:28:54.406] 
[01:28:54.406] getGlobalsAndPackages() ... DONE
[01:28:54.406] run() for 'Future' ...
[01:28:54.406] - state: 'created'
[01:28:54.407] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:54.407] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:54.407] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:54.407]   - Field: 'label'
[01:28:54.408]   - Field: 'local'
[01:28:54.408]   - Field: 'owner'
[01:28:54.408]   - Field: 'envir'
[01:28:54.408]   - Field: 'packages'
[01:28:54.408]   - Field: 'gc'
[01:28:54.408]   - Field: 'conditions'
[01:28:54.409]   - Field: 'expr'
[01:28:54.409]   - Field: 'uuid'
[01:28:54.409]   - Field: 'seed'
[01:28:54.409]   - Field: 'version'
[01:28:54.409]   - Field: 'result'
[01:28:54.410]   - Field: 'asynchronous'
[01:28:54.410]   - Field: 'calls'
[01:28:54.410]   - Field: 'globals'
[01:28:54.410]   - Field: 'stdout'
[01:28:54.410]   - Field: 'earlySignal'
[01:28:54.410]   - Field: 'lazy'
[01:28:54.411]   - Field: 'state'
[01:28:54.411] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:54.411] - Launch lazy future ...
[01:28:54.411] Packages needed by the future expression (n = 0): <none>
[01:28:54.411] Packages needed by future strategies (n = 0): <none>
[01:28:54.412] {
[01:28:54.412]     {
[01:28:54.412]         {
[01:28:54.412]             ...future.startTime <- base::Sys.time()
[01:28:54.412]             {
[01:28:54.412]                 {
[01:28:54.412]                   {
[01:28:54.412]                     base::local({
[01:28:54.412]                       has_future <- base::requireNamespace("future", 
[01:28:54.412]                         quietly = TRUE)
[01:28:54.412]                       if (has_future) {
[01:28:54.412]                         ns <- base::getNamespace("future")
[01:28:54.412]                         version <- ns[[".package"]][["version"]]
[01:28:54.412]                         if (is.null(version)) 
[01:28:54.412]                           version <- utils::packageVersion("future")
[01:28:54.412]                       }
[01:28:54.412]                       else {
[01:28:54.412]                         version <- NULL
[01:28:54.412]                       }
[01:28:54.412]                       if (!has_future || version < "1.8.0") {
[01:28:54.412]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:54.412]                           "", base::R.version$version.string), 
[01:28:54.412]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:54.412]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:54.412]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:54.412]                             "release", "version")], collapse = " "), 
[01:28:54.412]                           hostname = base::Sys.info()[["nodename"]])
[01:28:54.412]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:54.412]                           info)
[01:28:54.412]                         info <- base::paste(info, collapse = "; ")
[01:28:54.412]                         if (!has_future) {
[01:28:54.412]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:54.412]                             info)
[01:28:54.412]                         }
[01:28:54.412]                         else {
[01:28:54.412]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:54.412]                             info, version)
[01:28:54.412]                         }
[01:28:54.412]                         base::stop(msg)
[01:28:54.412]                       }
[01:28:54.412]                     })
[01:28:54.412]                   }
[01:28:54.412]                   options(future.plan = NULL)
[01:28:54.412]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:54.412]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:54.412]                 }
[01:28:54.412]                 ...future.workdir <- getwd()
[01:28:54.412]             }
[01:28:54.412]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:54.412]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:54.412]         }
[01:28:54.412]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:54.412]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:54.412]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:54.412]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:54.412]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:54.412]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:54.412]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:54.412]             base::names(...future.oldOptions))
[01:28:54.412]     }
[01:28:54.412]     if (FALSE) {
[01:28:54.412]     }
[01:28:54.412]     else {
[01:28:54.412]         if (TRUE) {
[01:28:54.412]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:54.412]                 open = "w")
[01:28:54.412]         }
[01:28:54.412]         else {
[01:28:54.412]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:54.412]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:54.412]         }
[01:28:54.412]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:54.412]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:54.412]             base::sink(type = "output", split = FALSE)
[01:28:54.412]             base::close(...future.stdout)
[01:28:54.412]         }, add = TRUE)
[01:28:54.412]     }
[01:28:54.412]     ...future.frame <- base::sys.nframe()
[01:28:54.412]     ...future.conditions <- base::list()
[01:28:54.412]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:54.412]     if (FALSE) {
[01:28:54.412]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:54.412]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:54.412]     }
[01:28:54.412]     ...future.result <- base::tryCatch({
[01:28:54.412]         base::withCallingHandlers({
[01:28:54.412]             ...future.value <- base::withVisible(base::local({
[01:28:54.412]                 1
[01:28:54.412]             }))
[01:28:54.412]             future::FutureResult(value = ...future.value$value, 
[01:28:54.412]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:54.412]                   ...future.rng), globalenv = if (FALSE) 
[01:28:54.412]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:54.412]                     ...future.globalenv.names))
[01:28:54.412]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:54.412]         }, condition = base::local({
[01:28:54.412]             c <- base::c
[01:28:54.412]             inherits <- base::inherits
[01:28:54.412]             invokeRestart <- base::invokeRestart
[01:28:54.412]             length <- base::length
[01:28:54.412]             list <- base::list
[01:28:54.412]             seq.int <- base::seq.int
[01:28:54.412]             signalCondition <- base::signalCondition
[01:28:54.412]             sys.calls <- base::sys.calls
[01:28:54.412]             `[[` <- base::`[[`
[01:28:54.412]             `+` <- base::`+`
[01:28:54.412]             `<<-` <- base::`<<-`
[01:28:54.412]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:54.412]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:54.412]                   3L)]
[01:28:54.412]             }
[01:28:54.412]             function(cond) {
[01:28:54.412]                 is_error <- inherits(cond, "error")
[01:28:54.412]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:54.412]                   NULL)
[01:28:54.412]                 if (is_error) {
[01:28:54.412]                   sessionInformation <- function() {
[01:28:54.412]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:54.412]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:54.412]                       search = base::search(), system = base::Sys.info())
[01:28:54.412]                   }
[01:28:54.412]                   ...future.conditions[[length(...future.conditions) + 
[01:28:54.412]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:54.412]                     cond$call), session = sessionInformation(), 
[01:28:54.412]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:54.412]                   signalCondition(cond)
[01:28:54.412]                 }
[01:28:54.412]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:54.412]                 "immediateCondition"))) {
[01:28:54.412]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:54.412]                   ...future.conditions[[length(...future.conditions) + 
[01:28:54.412]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:54.412]                   if (TRUE && !signal) {
[01:28:54.412]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:54.412]                     {
[01:28:54.412]                       inherits <- base::inherits
[01:28:54.412]                       invokeRestart <- base::invokeRestart
[01:28:54.412]                       is.null <- base::is.null
[01:28:54.412]                       muffled <- FALSE
[01:28:54.412]                       if (inherits(cond, "message")) {
[01:28:54.412]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:54.412]                         if (muffled) 
[01:28:54.412]                           invokeRestart("muffleMessage")
[01:28:54.412]                       }
[01:28:54.412]                       else if (inherits(cond, "warning")) {
[01:28:54.412]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:54.412]                         if (muffled) 
[01:28:54.412]                           invokeRestart("muffleWarning")
[01:28:54.412]                       }
[01:28:54.412]                       else if (inherits(cond, "condition")) {
[01:28:54.412]                         if (!is.null(pattern)) {
[01:28:54.412]                           computeRestarts <- base::computeRestarts
[01:28:54.412]                           grepl <- base::grepl
[01:28:54.412]                           restarts <- computeRestarts(cond)
[01:28:54.412]                           for (restart in restarts) {
[01:28:54.412]                             name <- restart$name
[01:28:54.412]                             if (is.null(name)) 
[01:28:54.412]                               next
[01:28:54.412]                             if (!grepl(pattern, name)) 
[01:28:54.412]                               next
[01:28:54.412]                             invokeRestart(restart)
[01:28:54.412]                             muffled <- TRUE
[01:28:54.412]                             break
[01:28:54.412]                           }
[01:28:54.412]                         }
[01:28:54.412]                       }
[01:28:54.412]                       invisible(muffled)
[01:28:54.412]                     }
[01:28:54.412]                     muffleCondition(cond, pattern = "^muffle")
[01:28:54.412]                   }
[01:28:54.412]                 }
[01:28:54.412]                 else {
[01:28:54.412]                   if (TRUE) {
[01:28:54.412]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:54.412]                     {
[01:28:54.412]                       inherits <- base::inherits
[01:28:54.412]                       invokeRestart <- base::invokeRestart
[01:28:54.412]                       is.null <- base::is.null
[01:28:54.412]                       muffled <- FALSE
[01:28:54.412]                       if (inherits(cond, "message")) {
[01:28:54.412]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:54.412]                         if (muffled) 
[01:28:54.412]                           invokeRestart("muffleMessage")
[01:28:54.412]                       }
[01:28:54.412]                       else if (inherits(cond, "warning")) {
[01:28:54.412]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:54.412]                         if (muffled) 
[01:28:54.412]                           invokeRestart("muffleWarning")
[01:28:54.412]                       }
[01:28:54.412]                       else if (inherits(cond, "condition")) {
[01:28:54.412]                         if (!is.null(pattern)) {
[01:28:54.412]                           computeRestarts <- base::computeRestarts
[01:28:54.412]                           grepl <- base::grepl
[01:28:54.412]                           restarts <- computeRestarts(cond)
[01:28:54.412]                           for (restart in restarts) {
[01:28:54.412]                             name <- restart$name
[01:28:54.412]                             if (is.null(name)) 
[01:28:54.412]                               next
[01:28:54.412]                             if (!grepl(pattern, name)) 
[01:28:54.412]                               next
[01:28:54.412]                             invokeRestart(restart)
[01:28:54.412]                             muffled <- TRUE
[01:28:54.412]                             break
[01:28:54.412]                           }
[01:28:54.412]                         }
[01:28:54.412]                       }
[01:28:54.412]                       invisible(muffled)
[01:28:54.412]                     }
[01:28:54.412]                     muffleCondition(cond, pattern = "^muffle")
[01:28:54.412]                   }
[01:28:54.412]                 }
[01:28:54.412]             }
[01:28:54.412]         }))
[01:28:54.412]     }, error = function(ex) {
[01:28:54.412]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:54.412]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:54.412]                 ...future.rng), started = ...future.startTime, 
[01:28:54.412]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:54.412]             version = "1.8"), class = "FutureResult")
[01:28:54.412]     }, finally = {
[01:28:54.412]         if (!identical(...future.workdir, getwd())) 
[01:28:54.412]             setwd(...future.workdir)
[01:28:54.412]         {
[01:28:54.412]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:54.412]                 ...future.oldOptions$nwarnings <- NULL
[01:28:54.412]             }
[01:28:54.412]             base::options(...future.oldOptions)
[01:28:54.412]             if (.Platform$OS.type == "windows") {
[01:28:54.412]                 old_names <- names(...future.oldEnvVars)
[01:28:54.412]                 envs <- base::Sys.getenv()
[01:28:54.412]                 names <- names(envs)
[01:28:54.412]                 common <- intersect(names, old_names)
[01:28:54.412]                 added <- setdiff(names, old_names)
[01:28:54.412]                 removed <- setdiff(old_names, names)
[01:28:54.412]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:54.412]                   envs[common]]
[01:28:54.412]                 NAMES <- toupper(changed)
[01:28:54.412]                 args <- list()
[01:28:54.412]                 for (kk in seq_along(NAMES)) {
[01:28:54.412]                   name <- changed[[kk]]
[01:28:54.412]                   NAME <- NAMES[[kk]]
[01:28:54.412]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.412]                     next
[01:28:54.412]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:54.412]                 }
[01:28:54.412]                 NAMES <- toupper(added)
[01:28:54.412]                 for (kk in seq_along(NAMES)) {
[01:28:54.412]                   name <- added[[kk]]
[01:28:54.412]                   NAME <- NAMES[[kk]]
[01:28:54.412]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.412]                     next
[01:28:54.412]                   args[[name]] <- ""
[01:28:54.412]                 }
[01:28:54.412]                 NAMES <- toupper(removed)
[01:28:54.412]                 for (kk in seq_along(NAMES)) {
[01:28:54.412]                   name <- removed[[kk]]
[01:28:54.412]                   NAME <- NAMES[[kk]]
[01:28:54.412]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.412]                     next
[01:28:54.412]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:54.412]                 }
[01:28:54.412]                 if (length(args) > 0) 
[01:28:54.412]                   base::do.call(base::Sys.setenv, args = args)
[01:28:54.412]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:54.412]             }
[01:28:54.412]             else {
[01:28:54.412]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:54.412]             }
[01:28:54.412]             {
[01:28:54.412]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:54.412]                   0L) {
[01:28:54.412]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:54.412]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:54.412]                   base::options(opts)
[01:28:54.412]                 }
[01:28:54.412]                 {
[01:28:54.412]                   {
[01:28:54.412]                     NULL
[01:28:54.412]                     RNGkind("Mersenne-Twister")
[01:28:54.412]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:54.412]                       inherits = FALSE)
[01:28:54.412]                   }
[01:28:54.412]                   options(future.plan = NULL)
[01:28:54.412]                   if (is.na(NA_character_)) 
[01:28:54.412]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:54.412]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:54.412]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:54.412]                   {
[01:28:54.412]                     future <- SequentialFuture(..., envir = envir)
[01:28:54.412]                     if (!future$lazy) 
[01:28:54.412]                       future <- run(future)
[01:28:54.412]                     invisible(future)
[01:28:54.412]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:54.412]                 }
[01:28:54.412]             }
[01:28:54.412]         }
[01:28:54.412]     })
[01:28:54.412]     if (TRUE) {
[01:28:54.412]         base::sink(type = "output", split = FALSE)
[01:28:54.412]         if (TRUE) {
[01:28:54.412]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:54.412]         }
[01:28:54.412]         else {
[01:28:54.412]             ...future.result["stdout"] <- base::list(NULL)
[01:28:54.412]         }
[01:28:54.412]         base::close(...future.stdout)
[01:28:54.412]         ...future.stdout <- NULL
[01:28:54.412]     }
[01:28:54.412]     ...future.result$conditions <- ...future.conditions
[01:28:54.412]     ...future.result$finished <- base::Sys.time()
[01:28:54.412]     ...future.result
[01:28:54.412] }
[01:28:54.416] plan(): Setting new future strategy stack:
[01:28:54.416] List of future strategies:
[01:28:54.416] 1. sequential:
[01:28:54.416]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:54.416]    - tweaked: FALSE
[01:28:54.416]    - call: NULL
[01:28:54.417] plan(): nbrOfWorkers() = 1
[01:28:54.418] plan(): Setting new future strategy stack:
[01:28:54.418] List of future strategies:
[01:28:54.418] 1. sequential:
[01:28:54.418]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:54.418]    - tweaked: FALSE
[01:28:54.418]    - call: plan(strategy)
[01:28:54.419] plan(): nbrOfWorkers() = 1
[01:28:54.419] SequentialFuture started (and completed)
[01:28:54.419] - Launch lazy future ... done
[01:28:54.419] run() for 'SequentialFuture' ... done
[01:28:54.420] getGlobalsAndPackages() ...
[01:28:54.420] Searching for globals...
[01:28:54.421] - globals found: [1] '{'
[01:28:54.421] Searching for globals ... DONE
[01:28:54.421] Resolving globals: FALSE
[01:28:54.422] 
[01:28:54.422] 
[01:28:54.422] getGlobalsAndPackages() ... DONE
[01:28:54.422] run() for 'Future' ...
[01:28:54.422] - state: 'created'
[01:28:54.423] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:54.423] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:54.423] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:54.423]   - Field: 'label'
[01:28:54.423]   - Field: 'local'
[01:28:54.424]   - Field: 'owner'
[01:28:54.424]   - Field: 'envir'
[01:28:54.424]   - Field: 'packages'
[01:28:54.424]   - Field: 'gc'
[01:28:54.424]   - Field: 'conditions'
[01:28:54.425]   - Field: 'expr'
[01:28:54.425]   - Field: 'uuid'
[01:28:54.425]   - Field: 'seed'
[01:28:54.425]   - Field: 'version'
[01:28:54.425]   - Field: 'result'
[01:28:54.425]   - Field: 'asynchronous'
[01:28:54.426]   - Field: 'calls'
[01:28:54.426]   - Field: 'globals'
[01:28:54.426]   - Field: 'stdout'
[01:28:54.426]   - Field: 'earlySignal'
[01:28:54.426]   - Field: 'lazy'
[01:28:54.427]   - Field: 'state'
[01:28:54.427] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:54.427] - Launch lazy future ...
[01:28:54.427] Packages needed by the future expression (n = 0): <none>
[01:28:54.427] Packages needed by future strategies (n = 0): <none>
[01:28:54.428] {
[01:28:54.428]     {
[01:28:54.428]         {
[01:28:54.428]             ...future.startTime <- base::Sys.time()
[01:28:54.428]             {
[01:28:54.428]                 {
[01:28:54.428]                   {
[01:28:54.428]                     base::local({
[01:28:54.428]                       has_future <- base::requireNamespace("future", 
[01:28:54.428]                         quietly = TRUE)
[01:28:54.428]                       if (has_future) {
[01:28:54.428]                         ns <- base::getNamespace("future")
[01:28:54.428]                         version <- ns[[".package"]][["version"]]
[01:28:54.428]                         if (is.null(version)) 
[01:28:54.428]                           version <- utils::packageVersion("future")
[01:28:54.428]                       }
[01:28:54.428]                       else {
[01:28:54.428]                         version <- NULL
[01:28:54.428]                       }
[01:28:54.428]                       if (!has_future || version < "1.8.0") {
[01:28:54.428]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:54.428]                           "", base::R.version$version.string), 
[01:28:54.428]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:54.428]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:54.428]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:54.428]                             "release", "version")], collapse = " "), 
[01:28:54.428]                           hostname = base::Sys.info()[["nodename"]])
[01:28:54.428]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:54.428]                           info)
[01:28:54.428]                         info <- base::paste(info, collapse = "; ")
[01:28:54.428]                         if (!has_future) {
[01:28:54.428]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:54.428]                             info)
[01:28:54.428]                         }
[01:28:54.428]                         else {
[01:28:54.428]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:54.428]                             info, version)
[01:28:54.428]                         }
[01:28:54.428]                         base::stop(msg)
[01:28:54.428]                       }
[01:28:54.428]                     })
[01:28:54.428]                   }
[01:28:54.428]                   options(future.plan = NULL)
[01:28:54.428]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:54.428]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:54.428]                 }
[01:28:54.428]                 ...future.workdir <- getwd()
[01:28:54.428]             }
[01:28:54.428]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:54.428]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:54.428]         }
[01:28:54.428]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:54.428]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:54.428]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:54.428]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:54.428]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:54.428]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:54.428]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:54.428]             base::names(...future.oldOptions))
[01:28:54.428]     }
[01:28:54.428]     if (FALSE) {
[01:28:54.428]     }
[01:28:54.428]     else {
[01:28:54.428]         if (TRUE) {
[01:28:54.428]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:54.428]                 open = "w")
[01:28:54.428]         }
[01:28:54.428]         else {
[01:28:54.428]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:54.428]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:54.428]         }
[01:28:54.428]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:54.428]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:54.428]             base::sink(type = "output", split = FALSE)
[01:28:54.428]             base::close(...future.stdout)
[01:28:54.428]         }, add = TRUE)
[01:28:54.428]     }
[01:28:54.428]     ...future.frame <- base::sys.nframe()
[01:28:54.428]     ...future.conditions <- base::list()
[01:28:54.428]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:54.428]     if (FALSE) {
[01:28:54.428]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:54.428]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:54.428]     }
[01:28:54.428]     ...future.result <- base::tryCatch({
[01:28:54.428]         base::withCallingHandlers({
[01:28:54.428]             ...future.value <- base::withVisible(base::local({
[01:28:54.428]                 2
[01:28:54.428]             }))
[01:28:54.428]             future::FutureResult(value = ...future.value$value, 
[01:28:54.428]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:54.428]                   ...future.rng), globalenv = if (FALSE) 
[01:28:54.428]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:54.428]                     ...future.globalenv.names))
[01:28:54.428]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:54.428]         }, condition = base::local({
[01:28:54.428]             c <- base::c
[01:28:54.428]             inherits <- base::inherits
[01:28:54.428]             invokeRestart <- base::invokeRestart
[01:28:54.428]             length <- base::length
[01:28:54.428]             list <- base::list
[01:28:54.428]             seq.int <- base::seq.int
[01:28:54.428]             signalCondition <- base::signalCondition
[01:28:54.428]             sys.calls <- base::sys.calls
[01:28:54.428]             `[[` <- base::`[[`
[01:28:54.428]             `+` <- base::`+`
[01:28:54.428]             `<<-` <- base::`<<-`
[01:28:54.428]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:54.428]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:54.428]                   3L)]
[01:28:54.428]             }
[01:28:54.428]             function(cond) {
[01:28:54.428]                 is_error <- inherits(cond, "error")
[01:28:54.428]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:54.428]                   NULL)
[01:28:54.428]                 if (is_error) {
[01:28:54.428]                   sessionInformation <- function() {
[01:28:54.428]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:54.428]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:54.428]                       search = base::search(), system = base::Sys.info())
[01:28:54.428]                   }
[01:28:54.428]                   ...future.conditions[[length(...future.conditions) + 
[01:28:54.428]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:54.428]                     cond$call), session = sessionInformation(), 
[01:28:54.428]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:54.428]                   signalCondition(cond)
[01:28:54.428]                 }
[01:28:54.428]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:54.428]                 "immediateCondition"))) {
[01:28:54.428]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:54.428]                   ...future.conditions[[length(...future.conditions) + 
[01:28:54.428]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:54.428]                   if (TRUE && !signal) {
[01:28:54.428]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:54.428]                     {
[01:28:54.428]                       inherits <- base::inherits
[01:28:54.428]                       invokeRestart <- base::invokeRestart
[01:28:54.428]                       is.null <- base::is.null
[01:28:54.428]                       muffled <- FALSE
[01:28:54.428]                       if (inherits(cond, "message")) {
[01:28:54.428]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:54.428]                         if (muffled) 
[01:28:54.428]                           invokeRestart("muffleMessage")
[01:28:54.428]                       }
[01:28:54.428]                       else if (inherits(cond, "warning")) {
[01:28:54.428]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:54.428]                         if (muffled) 
[01:28:54.428]                           invokeRestart("muffleWarning")
[01:28:54.428]                       }
[01:28:54.428]                       else if (inherits(cond, "condition")) {
[01:28:54.428]                         if (!is.null(pattern)) {
[01:28:54.428]                           computeRestarts <- base::computeRestarts
[01:28:54.428]                           grepl <- base::grepl
[01:28:54.428]                           restarts <- computeRestarts(cond)
[01:28:54.428]                           for (restart in restarts) {
[01:28:54.428]                             name <- restart$name
[01:28:54.428]                             if (is.null(name)) 
[01:28:54.428]                               next
[01:28:54.428]                             if (!grepl(pattern, name)) 
[01:28:54.428]                               next
[01:28:54.428]                             invokeRestart(restart)
[01:28:54.428]                             muffled <- TRUE
[01:28:54.428]                             break
[01:28:54.428]                           }
[01:28:54.428]                         }
[01:28:54.428]                       }
[01:28:54.428]                       invisible(muffled)
[01:28:54.428]                     }
[01:28:54.428]                     muffleCondition(cond, pattern = "^muffle")
[01:28:54.428]                   }
[01:28:54.428]                 }
[01:28:54.428]                 else {
[01:28:54.428]                   if (TRUE) {
[01:28:54.428]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:54.428]                     {
[01:28:54.428]                       inherits <- base::inherits
[01:28:54.428]                       invokeRestart <- base::invokeRestart
[01:28:54.428]                       is.null <- base::is.null
[01:28:54.428]                       muffled <- FALSE
[01:28:54.428]                       if (inherits(cond, "message")) {
[01:28:54.428]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:54.428]                         if (muffled) 
[01:28:54.428]                           invokeRestart("muffleMessage")
[01:28:54.428]                       }
[01:28:54.428]                       else if (inherits(cond, "warning")) {
[01:28:54.428]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:54.428]                         if (muffled) 
[01:28:54.428]                           invokeRestart("muffleWarning")
[01:28:54.428]                       }
[01:28:54.428]                       else if (inherits(cond, "condition")) {
[01:28:54.428]                         if (!is.null(pattern)) {
[01:28:54.428]                           computeRestarts <- base::computeRestarts
[01:28:54.428]                           grepl <- base::grepl
[01:28:54.428]                           restarts <- computeRestarts(cond)
[01:28:54.428]                           for (restart in restarts) {
[01:28:54.428]                             name <- restart$name
[01:28:54.428]                             if (is.null(name)) 
[01:28:54.428]                               next
[01:28:54.428]                             if (!grepl(pattern, name)) 
[01:28:54.428]                               next
[01:28:54.428]                             invokeRestart(restart)
[01:28:54.428]                             muffled <- TRUE
[01:28:54.428]                             break
[01:28:54.428]                           }
[01:28:54.428]                         }
[01:28:54.428]                       }
[01:28:54.428]                       invisible(muffled)
[01:28:54.428]                     }
[01:28:54.428]                     muffleCondition(cond, pattern = "^muffle")
[01:28:54.428]                   }
[01:28:54.428]                 }
[01:28:54.428]             }
[01:28:54.428]         }))
[01:28:54.428]     }, error = function(ex) {
[01:28:54.428]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:54.428]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:54.428]                 ...future.rng), started = ...future.startTime, 
[01:28:54.428]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:54.428]             version = "1.8"), class = "FutureResult")
[01:28:54.428]     }, finally = {
[01:28:54.428]         if (!identical(...future.workdir, getwd())) 
[01:28:54.428]             setwd(...future.workdir)
[01:28:54.428]         {
[01:28:54.428]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:54.428]                 ...future.oldOptions$nwarnings <- NULL
[01:28:54.428]             }
[01:28:54.428]             base::options(...future.oldOptions)
[01:28:54.428]             if (.Platform$OS.type == "windows") {
[01:28:54.428]                 old_names <- names(...future.oldEnvVars)
[01:28:54.428]                 envs <- base::Sys.getenv()
[01:28:54.428]                 names <- names(envs)
[01:28:54.428]                 common <- intersect(names, old_names)
[01:28:54.428]                 added <- setdiff(names, old_names)
[01:28:54.428]                 removed <- setdiff(old_names, names)
[01:28:54.428]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:54.428]                   envs[common]]
[01:28:54.428]                 NAMES <- toupper(changed)
[01:28:54.428]                 args <- list()
[01:28:54.428]                 for (kk in seq_along(NAMES)) {
[01:28:54.428]                   name <- changed[[kk]]
[01:28:54.428]                   NAME <- NAMES[[kk]]
[01:28:54.428]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.428]                     next
[01:28:54.428]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:54.428]                 }
[01:28:54.428]                 NAMES <- toupper(added)
[01:28:54.428]                 for (kk in seq_along(NAMES)) {
[01:28:54.428]                   name <- added[[kk]]
[01:28:54.428]                   NAME <- NAMES[[kk]]
[01:28:54.428]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.428]                     next
[01:28:54.428]                   args[[name]] <- ""
[01:28:54.428]                 }
[01:28:54.428]                 NAMES <- toupper(removed)
[01:28:54.428]                 for (kk in seq_along(NAMES)) {
[01:28:54.428]                   name <- removed[[kk]]
[01:28:54.428]                   NAME <- NAMES[[kk]]
[01:28:54.428]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.428]                     next
[01:28:54.428]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:54.428]                 }
[01:28:54.428]                 if (length(args) > 0) 
[01:28:54.428]                   base::do.call(base::Sys.setenv, args = args)
[01:28:54.428]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:54.428]             }
[01:28:54.428]             else {
[01:28:54.428]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:54.428]             }
[01:28:54.428]             {
[01:28:54.428]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:54.428]                   0L) {
[01:28:54.428]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:54.428]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:54.428]                   base::options(opts)
[01:28:54.428]                 }
[01:28:54.428]                 {
[01:28:54.428]                   {
[01:28:54.428]                     NULL
[01:28:54.428]                     RNGkind("Mersenne-Twister")
[01:28:54.428]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:54.428]                       inherits = FALSE)
[01:28:54.428]                   }
[01:28:54.428]                   options(future.plan = NULL)
[01:28:54.428]                   if (is.na(NA_character_)) 
[01:28:54.428]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:54.428]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:54.428]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:54.428]                   {
[01:28:54.428]                     future <- SequentialFuture(..., envir = envir)
[01:28:54.428]                     if (!future$lazy) 
[01:28:54.428]                       future <- run(future)
[01:28:54.428]                     invisible(future)
[01:28:54.428]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:54.428]                 }
[01:28:54.428]             }
[01:28:54.428]         }
[01:28:54.428]     })
[01:28:54.428]     if (TRUE) {
[01:28:54.428]         base::sink(type = "output", split = FALSE)
[01:28:54.428]         if (TRUE) {
[01:28:54.428]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:54.428]         }
[01:28:54.428]         else {
[01:28:54.428]             ...future.result["stdout"] <- base::list(NULL)
[01:28:54.428]         }
[01:28:54.428]         base::close(...future.stdout)
[01:28:54.428]         ...future.stdout <- NULL
[01:28:54.428]     }
[01:28:54.428]     ...future.result$conditions <- ...future.conditions
[01:28:54.428]     ...future.result$finished <- base::Sys.time()
[01:28:54.428]     ...future.result
[01:28:54.428] }
[01:28:54.434] plan(): Setting new future strategy stack:
[01:28:54.434] List of future strategies:
[01:28:54.434] 1. sequential:
[01:28:54.434]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:54.434]    - tweaked: FALSE
[01:28:54.434]    - call: NULL
[01:28:54.434] plan(): nbrOfWorkers() = 1
[01:28:54.436] plan(): Setting new future strategy stack:
[01:28:54.436] List of future strategies:
[01:28:54.436] 1. sequential:
[01:28:54.436]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:54.436]    - tweaked: FALSE
[01:28:54.436]    - call: plan(strategy)
[01:28:54.436] plan(): nbrOfWorkers() = 1
[01:28:54.437] SequentialFuture started (and completed)
[01:28:54.437] - Launch lazy future ... done
[01:28:54.437] run() for 'SequentialFuture' ... done
[01:28:54.438] resolve() on environment ...
[01:28:54.438]  recursive: 0
[01:28:54.438]  elements: [3] '.future_a', '.future_b', 'a', 'b', 'c'
[01:28:54.439] resolved() for 'SequentialFuture' ...
[01:28:54.439] - state: 'finished'
[01:28:54.439] - run: TRUE
[01:28:54.439] - result: 'FutureResult'
[01:28:54.439] resolved() for 'SequentialFuture' ... done
[01:28:54.440] Future #1
[01:28:54.440]  length: 2 (resolved future 1)
[01:28:54.440] resolved() for 'SequentialFuture' ...
[01:28:54.440] - state: 'finished'
[01:28:54.440] - run: TRUE
[01:28:54.441] - result: 'FutureResult'
[01:28:54.441] resolved() for 'SequentialFuture' ... done
[01:28:54.441] Future #2
[01:28:54.441]  length: 1 (resolved future 2)
[01:28:54.441]  length: 0 (resolved future 3)
[01:28:54.441] resolve() on environment ... DONE
[01:28:54.442] getGlobalsAndPackages() ...
[01:28:54.442] Searching for globals...
[01:28:54.443] - globals found: [1] '{'
[01:28:54.443] Searching for globals ... DONE
[01:28:54.443] Resolving globals: FALSE
[01:28:54.444] 
[01:28:54.444] 
[01:28:54.444] getGlobalsAndPackages() ... DONE
[01:28:54.444] run() for 'Future' ...
[01:28:54.444] - state: 'created'
[01:28:54.445] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:54.445] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:54.445] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:54.445]   - Field: 'label'
[01:28:54.446]   - Field: 'local'
[01:28:54.446]   - Field: 'owner'
[01:28:54.446]   - Field: 'envir'
[01:28:54.446]   - Field: 'packages'
[01:28:54.446]   - Field: 'gc'
[01:28:54.446]   - Field: 'conditions'
[01:28:54.447]   - Field: 'expr'
[01:28:54.447]   - Field: 'uuid'
[01:28:54.447]   - Field: 'seed'
[01:28:54.447]   - Field: 'version'
[01:28:54.447]   - Field: 'result'
[01:28:54.448]   - Field: 'asynchronous'
[01:28:54.448]   - Field: 'calls'
[01:28:54.448]   - Field: 'globals'
[01:28:54.448]   - Field: 'stdout'
[01:28:54.448]   - Field: 'earlySignal'
[01:28:54.448]   - Field: 'lazy'
[01:28:54.449]   - Field: 'state'
[01:28:54.449] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:54.449] - Launch lazy future ...
[01:28:54.449] Packages needed by the future expression (n = 0): <none>
[01:28:54.449] Packages needed by future strategies (n = 0): <none>
[01:28:54.450] {
[01:28:54.450]     {
[01:28:54.450]         {
[01:28:54.450]             ...future.startTime <- base::Sys.time()
[01:28:54.450]             {
[01:28:54.450]                 {
[01:28:54.450]                   {
[01:28:54.450]                     base::local({
[01:28:54.450]                       has_future <- base::requireNamespace("future", 
[01:28:54.450]                         quietly = TRUE)
[01:28:54.450]                       if (has_future) {
[01:28:54.450]                         ns <- base::getNamespace("future")
[01:28:54.450]                         version <- ns[[".package"]][["version"]]
[01:28:54.450]                         if (is.null(version)) 
[01:28:54.450]                           version <- utils::packageVersion("future")
[01:28:54.450]                       }
[01:28:54.450]                       else {
[01:28:54.450]                         version <- NULL
[01:28:54.450]                       }
[01:28:54.450]                       if (!has_future || version < "1.8.0") {
[01:28:54.450]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:54.450]                           "", base::R.version$version.string), 
[01:28:54.450]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:54.450]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:54.450]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:54.450]                             "release", "version")], collapse = " "), 
[01:28:54.450]                           hostname = base::Sys.info()[["nodename"]])
[01:28:54.450]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:54.450]                           info)
[01:28:54.450]                         info <- base::paste(info, collapse = "; ")
[01:28:54.450]                         if (!has_future) {
[01:28:54.450]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:54.450]                             info)
[01:28:54.450]                         }
[01:28:54.450]                         else {
[01:28:54.450]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:54.450]                             info, version)
[01:28:54.450]                         }
[01:28:54.450]                         base::stop(msg)
[01:28:54.450]                       }
[01:28:54.450]                     })
[01:28:54.450]                   }
[01:28:54.450]                   options(future.plan = NULL)
[01:28:54.450]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:54.450]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:54.450]                 }
[01:28:54.450]                 ...future.workdir <- getwd()
[01:28:54.450]             }
[01:28:54.450]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:54.450]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:54.450]         }
[01:28:54.450]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:54.450]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:54.450]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:54.450]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:54.450]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:54.450]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:54.450]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:54.450]             base::names(...future.oldOptions))
[01:28:54.450]     }
[01:28:54.450]     if (FALSE) {
[01:28:54.450]     }
[01:28:54.450]     else {
[01:28:54.450]         if (TRUE) {
[01:28:54.450]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:54.450]                 open = "w")
[01:28:54.450]         }
[01:28:54.450]         else {
[01:28:54.450]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:54.450]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:54.450]         }
[01:28:54.450]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:54.450]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:54.450]             base::sink(type = "output", split = FALSE)
[01:28:54.450]             base::close(...future.stdout)
[01:28:54.450]         }, add = TRUE)
[01:28:54.450]     }
[01:28:54.450]     ...future.frame <- base::sys.nframe()
[01:28:54.450]     ...future.conditions <- base::list()
[01:28:54.450]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:54.450]     if (FALSE) {
[01:28:54.450]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:54.450]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:54.450]     }
[01:28:54.450]     ...future.result <- base::tryCatch({
[01:28:54.450]         base::withCallingHandlers({
[01:28:54.450]             ...future.value <- base::withVisible(base::local({
[01:28:54.450]                 1
[01:28:54.450]             }))
[01:28:54.450]             future::FutureResult(value = ...future.value$value, 
[01:28:54.450]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:54.450]                   ...future.rng), globalenv = if (FALSE) 
[01:28:54.450]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:54.450]                     ...future.globalenv.names))
[01:28:54.450]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:54.450]         }, condition = base::local({
[01:28:54.450]             c <- base::c
[01:28:54.450]             inherits <- base::inherits
[01:28:54.450]             invokeRestart <- base::invokeRestart
[01:28:54.450]             length <- base::length
[01:28:54.450]             list <- base::list
[01:28:54.450]             seq.int <- base::seq.int
[01:28:54.450]             signalCondition <- base::signalCondition
[01:28:54.450]             sys.calls <- base::sys.calls
[01:28:54.450]             `[[` <- base::`[[`
[01:28:54.450]             `+` <- base::`+`
[01:28:54.450]             `<<-` <- base::`<<-`
[01:28:54.450]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:54.450]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:54.450]                   3L)]
[01:28:54.450]             }
[01:28:54.450]             function(cond) {
[01:28:54.450]                 is_error <- inherits(cond, "error")
[01:28:54.450]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:54.450]                   NULL)
[01:28:54.450]                 if (is_error) {
[01:28:54.450]                   sessionInformation <- function() {
[01:28:54.450]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:54.450]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:54.450]                       search = base::search(), system = base::Sys.info())
[01:28:54.450]                   }
[01:28:54.450]                   ...future.conditions[[length(...future.conditions) + 
[01:28:54.450]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:54.450]                     cond$call), session = sessionInformation(), 
[01:28:54.450]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:54.450]                   signalCondition(cond)
[01:28:54.450]                 }
[01:28:54.450]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:54.450]                 "immediateCondition"))) {
[01:28:54.450]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:54.450]                   ...future.conditions[[length(...future.conditions) + 
[01:28:54.450]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:54.450]                   if (TRUE && !signal) {
[01:28:54.450]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:54.450]                     {
[01:28:54.450]                       inherits <- base::inherits
[01:28:54.450]                       invokeRestart <- base::invokeRestart
[01:28:54.450]                       is.null <- base::is.null
[01:28:54.450]                       muffled <- FALSE
[01:28:54.450]                       if (inherits(cond, "message")) {
[01:28:54.450]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:54.450]                         if (muffled) 
[01:28:54.450]                           invokeRestart("muffleMessage")
[01:28:54.450]                       }
[01:28:54.450]                       else if (inherits(cond, "warning")) {
[01:28:54.450]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:54.450]                         if (muffled) 
[01:28:54.450]                           invokeRestart("muffleWarning")
[01:28:54.450]                       }
[01:28:54.450]                       else if (inherits(cond, "condition")) {
[01:28:54.450]                         if (!is.null(pattern)) {
[01:28:54.450]                           computeRestarts <- base::computeRestarts
[01:28:54.450]                           grepl <- base::grepl
[01:28:54.450]                           restarts <- computeRestarts(cond)
[01:28:54.450]                           for (restart in restarts) {
[01:28:54.450]                             name <- restart$name
[01:28:54.450]                             if (is.null(name)) 
[01:28:54.450]                               next
[01:28:54.450]                             if (!grepl(pattern, name)) 
[01:28:54.450]                               next
[01:28:54.450]                             invokeRestart(restart)
[01:28:54.450]                             muffled <- TRUE
[01:28:54.450]                             break
[01:28:54.450]                           }
[01:28:54.450]                         }
[01:28:54.450]                       }
[01:28:54.450]                       invisible(muffled)
[01:28:54.450]                     }
[01:28:54.450]                     muffleCondition(cond, pattern = "^muffle")
[01:28:54.450]                   }
[01:28:54.450]                 }
[01:28:54.450]                 else {
[01:28:54.450]                   if (TRUE) {
[01:28:54.450]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:54.450]                     {
[01:28:54.450]                       inherits <- base::inherits
[01:28:54.450]                       invokeRestart <- base::invokeRestart
[01:28:54.450]                       is.null <- base::is.null
[01:28:54.450]                       muffled <- FALSE
[01:28:54.450]                       if (inherits(cond, "message")) {
[01:28:54.450]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:54.450]                         if (muffled) 
[01:28:54.450]                           invokeRestart("muffleMessage")
[01:28:54.450]                       }
[01:28:54.450]                       else if (inherits(cond, "warning")) {
[01:28:54.450]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:54.450]                         if (muffled) 
[01:28:54.450]                           invokeRestart("muffleWarning")
[01:28:54.450]                       }
[01:28:54.450]                       else if (inherits(cond, "condition")) {
[01:28:54.450]                         if (!is.null(pattern)) {
[01:28:54.450]                           computeRestarts <- base::computeRestarts
[01:28:54.450]                           grepl <- base::grepl
[01:28:54.450]                           restarts <- computeRestarts(cond)
[01:28:54.450]                           for (restart in restarts) {
[01:28:54.450]                             name <- restart$name
[01:28:54.450]                             if (is.null(name)) 
[01:28:54.450]                               next
[01:28:54.450]                             if (!grepl(pattern, name)) 
[01:28:54.450]                               next
[01:28:54.450]                             invokeRestart(restart)
[01:28:54.450]                             muffled <- TRUE
[01:28:54.450]                             break
[01:28:54.450]                           }
[01:28:54.450]                         }
[01:28:54.450]                       }
[01:28:54.450]                       invisible(muffled)
[01:28:54.450]                     }
[01:28:54.450]                     muffleCondition(cond, pattern = "^muffle")
[01:28:54.450]                   }
[01:28:54.450]                 }
[01:28:54.450]             }
[01:28:54.450]         }))
[01:28:54.450]     }, error = function(ex) {
[01:28:54.450]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:54.450]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:54.450]                 ...future.rng), started = ...future.startTime, 
[01:28:54.450]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:54.450]             version = "1.8"), class = "FutureResult")
[01:28:54.450]     }, finally = {
[01:28:54.450]         if (!identical(...future.workdir, getwd())) 
[01:28:54.450]             setwd(...future.workdir)
[01:28:54.450]         {
[01:28:54.450]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:54.450]                 ...future.oldOptions$nwarnings <- NULL
[01:28:54.450]             }
[01:28:54.450]             base::options(...future.oldOptions)
[01:28:54.450]             if (.Platform$OS.type == "windows") {
[01:28:54.450]                 old_names <- names(...future.oldEnvVars)
[01:28:54.450]                 envs <- base::Sys.getenv()
[01:28:54.450]                 names <- names(envs)
[01:28:54.450]                 common <- intersect(names, old_names)
[01:28:54.450]                 added <- setdiff(names, old_names)
[01:28:54.450]                 removed <- setdiff(old_names, names)
[01:28:54.450]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:54.450]                   envs[common]]
[01:28:54.450]                 NAMES <- toupper(changed)
[01:28:54.450]                 args <- list()
[01:28:54.450]                 for (kk in seq_along(NAMES)) {
[01:28:54.450]                   name <- changed[[kk]]
[01:28:54.450]                   NAME <- NAMES[[kk]]
[01:28:54.450]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.450]                     next
[01:28:54.450]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:54.450]                 }
[01:28:54.450]                 NAMES <- toupper(added)
[01:28:54.450]                 for (kk in seq_along(NAMES)) {
[01:28:54.450]                   name <- added[[kk]]
[01:28:54.450]                   NAME <- NAMES[[kk]]
[01:28:54.450]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.450]                     next
[01:28:54.450]                   args[[name]] <- ""
[01:28:54.450]                 }
[01:28:54.450]                 NAMES <- toupper(removed)
[01:28:54.450]                 for (kk in seq_along(NAMES)) {
[01:28:54.450]                   name <- removed[[kk]]
[01:28:54.450]                   NAME <- NAMES[[kk]]
[01:28:54.450]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.450]                     next
[01:28:54.450]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:54.450]                 }
[01:28:54.450]                 if (length(args) > 0) 
[01:28:54.450]                   base::do.call(base::Sys.setenv, args = args)
[01:28:54.450]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:54.450]             }
[01:28:54.450]             else {
[01:28:54.450]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:54.450]             }
[01:28:54.450]             {
[01:28:54.450]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:54.450]                   0L) {
[01:28:54.450]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:54.450]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:54.450]                   base::options(opts)
[01:28:54.450]                 }
[01:28:54.450]                 {
[01:28:54.450]                   {
[01:28:54.450]                     NULL
[01:28:54.450]                     RNGkind("Mersenne-Twister")
[01:28:54.450]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:54.450]                       inherits = FALSE)
[01:28:54.450]                   }
[01:28:54.450]                   options(future.plan = NULL)
[01:28:54.450]                   if (is.na(NA_character_)) 
[01:28:54.450]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:54.450]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:54.450]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:54.450]                   {
[01:28:54.450]                     future <- SequentialFuture(..., envir = envir)
[01:28:54.450]                     if (!future$lazy) 
[01:28:54.450]                       future <- run(future)
[01:28:54.450]                     invisible(future)
[01:28:54.450]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:54.450]                 }
[01:28:54.450]             }
[01:28:54.450]         }
[01:28:54.450]     })
[01:28:54.450]     if (TRUE) {
[01:28:54.450]         base::sink(type = "output", split = FALSE)
[01:28:54.450]         if (TRUE) {
[01:28:54.450]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:54.450]         }
[01:28:54.450]         else {
[01:28:54.450]             ...future.result["stdout"] <- base::list(NULL)
[01:28:54.450]         }
[01:28:54.450]         base::close(...future.stdout)
[01:28:54.450]         ...future.stdout <- NULL
[01:28:54.450]     }
[01:28:54.450]     ...future.result$conditions <- ...future.conditions
[01:28:54.450]     ...future.result$finished <- base::Sys.time()
[01:28:54.450]     ...future.result
[01:28:54.450] }
[01:28:54.454] plan(): Setting new future strategy stack:
[01:28:54.454] List of future strategies:
[01:28:54.454] 1. sequential:
[01:28:54.454]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:54.454]    - tweaked: FALSE
[01:28:54.454]    - call: NULL
[01:28:54.455] plan(): nbrOfWorkers() = 1
[01:28:54.456] plan(): Setting new future strategy stack:
[01:28:54.456] List of future strategies:
[01:28:54.456] 1. sequential:
[01:28:54.456]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:54.456]    - tweaked: FALSE
[01:28:54.456]    - call: plan(strategy)
[01:28:54.457] plan(): nbrOfWorkers() = 1
[01:28:54.457] SequentialFuture started (and completed)
[01:28:54.457] - Launch lazy future ... done
[01:28:54.457] run() for 'SequentialFuture' ... done
[01:28:54.458] getGlobalsAndPackages() ...
[01:28:54.458] Searching for globals...
[01:28:54.459] - globals found: [1] '{'
[01:28:54.459] Searching for globals ... DONE
[01:28:54.459] Resolving globals: FALSE
[01:28:54.459] 
[01:28:54.459] 
[01:28:54.460] getGlobalsAndPackages() ... DONE
[01:28:54.460] run() for 'Future' ...
[01:28:54.460] - state: 'created'
[01:28:54.460] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:54.461] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:54.461] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:54.461]   - Field: 'label'
[01:28:54.461]   - Field: 'local'
[01:28:54.461]   - Field: 'owner'
[01:28:54.462]   - Field: 'envir'
[01:28:54.462]   - Field: 'packages'
[01:28:54.462]   - Field: 'gc'
[01:28:54.462]   - Field: 'conditions'
[01:28:54.462]   - Field: 'expr'
[01:28:54.462]   - Field: 'uuid'
[01:28:54.463]   - Field: 'seed'
[01:28:54.463]   - Field: 'version'
[01:28:54.463]   - Field: 'result'
[01:28:54.463]   - Field: 'asynchronous'
[01:28:54.463]   - Field: 'calls'
[01:28:54.464]   - Field: 'globals'
[01:28:54.464]   - Field: 'stdout'
[01:28:54.464]   - Field: 'earlySignal'
[01:28:54.464]   - Field: 'lazy'
[01:28:54.464]   - Field: 'state'
[01:28:54.464] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:54.465] - Launch lazy future ...
[01:28:54.465] Packages needed by the future expression (n = 0): <none>
[01:28:54.465] Packages needed by future strategies (n = 0): <none>
[01:28:54.467] {
[01:28:54.467]     {
[01:28:54.467]         {
[01:28:54.467]             ...future.startTime <- base::Sys.time()
[01:28:54.467]             {
[01:28:54.467]                 {
[01:28:54.467]                   {
[01:28:54.467]                     base::local({
[01:28:54.467]                       has_future <- base::requireNamespace("future", 
[01:28:54.467]                         quietly = TRUE)
[01:28:54.467]                       if (has_future) {
[01:28:54.467]                         ns <- base::getNamespace("future")
[01:28:54.467]                         version <- ns[[".package"]][["version"]]
[01:28:54.467]                         if (is.null(version)) 
[01:28:54.467]                           version <- utils::packageVersion("future")
[01:28:54.467]                       }
[01:28:54.467]                       else {
[01:28:54.467]                         version <- NULL
[01:28:54.467]                       }
[01:28:54.467]                       if (!has_future || version < "1.8.0") {
[01:28:54.467]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:54.467]                           "", base::R.version$version.string), 
[01:28:54.467]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:54.467]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:54.467]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:54.467]                             "release", "version")], collapse = " "), 
[01:28:54.467]                           hostname = base::Sys.info()[["nodename"]])
[01:28:54.467]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:54.467]                           info)
[01:28:54.467]                         info <- base::paste(info, collapse = "; ")
[01:28:54.467]                         if (!has_future) {
[01:28:54.467]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:54.467]                             info)
[01:28:54.467]                         }
[01:28:54.467]                         else {
[01:28:54.467]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:54.467]                             info, version)
[01:28:54.467]                         }
[01:28:54.467]                         base::stop(msg)
[01:28:54.467]                       }
[01:28:54.467]                     })
[01:28:54.467]                   }
[01:28:54.467]                   options(future.plan = NULL)
[01:28:54.467]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:54.467]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:54.467]                 }
[01:28:54.467]                 ...future.workdir <- getwd()
[01:28:54.467]             }
[01:28:54.467]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:54.467]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:54.467]         }
[01:28:54.467]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:54.467]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:54.467]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:54.467]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:54.467]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:54.467]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:54.467]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:54.467]             base::names(...future.oldOptions))
[01:28:54.467]     }
[01:28:54.467]     if (FALSE) {
[01:28:54.467]     }
[01:28:54.467]     else {
[01:28:54.467]         if (TRUE) {
[01:28:54.467]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:54.467]                 open = "w")
[01:28:54.467]         }
[01:28:54.467]         else {
[01:28:54.467]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:54.467]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:54.467]         }
[01:28:54.467]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:54.467]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:54.467]             base::sink(type = "output", split = FALSE)
[01:28:54.467]             base::close(...future.stdout)
[01:28:54.467]         }, add = TRUE)
[01:28:54.467]     }
[01:28:54.467]     ...future.frame <- base::sys.nframe()
[01:28:54.467]     ...future.conditions <- base::list()
[01:28:54.467]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:54.467]     if (FALSE) {
[01:28:54.467]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:54.467]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:54.467]     }
[01:28:54.467]     ...future.result <- base::tryCatch({
[01:28:54.467]         base::withCallingHandlers({
[01:28:54.467]             ...future.value <- base::withVisible(base::local({
[01:28:54.467]                 2
[01:28:54.467]             }))
[01:28:54.467]             future::FutureResult(value = ...future.value$value, 
[01:28:54.467]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:54.467]                   ...future.rng), globalenv = if (FALSE) 
[01:28:54.467]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:54.467]                     ...future.globalenv.names))
[01:28:54.467]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:54.467]         }, condition = base::local({
[01:28:54.467]             c <- base::c
[01:28:54.467]             inherits <- base::inherits
[01:28:54.467]             invokeRestart <- base::invokeRestart
[01:28:54.467]             length <- base::length
[01:28:54.467]             list <- base::list
[01:28:54.467]             seq.int <- base::seq.int
[01:28:54.467]             signalCondition <- base::signalCondition
[01:28:54.467]             sys.calls <- base::sys.calls
[01:28:54.467]             `[[` <- base::`[[`
[01:28:54.467]             `+` <- base::`+`
[01:28:54.467]             `<<-` <- base::`<<-`
[01:28:54.467]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:54.467]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:54.467]                   3L)]
[01:28:54.467]             }
[01:28:54.467]             function(cond) {
[01:28:54.467]                 is_error <- inherits(cond, "error")
[01:28:54.467]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:54.467]                   NULL)
[01:28:54.467]                 if (is_error) {
[01:28:54.467]                   sessionInformation <- function() {
[01:28:54.467]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:54.467]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:54.467]                       search = base::search(), system = base::Sys.info())
[01:28:54.467]                   }
[01:28:54.467]                   ...future.conditions[[length(...future.conditions) + 
[01:28:54.467]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:54.467]                     cond$call), session = sessionInformation(), 
[01:28:54.467]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:54.467]                   signalCondition(cond)
[01:28:54.467]                 }
[01:28:54.467]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:54.467]                 "immediateCondition"))) {
[01:28:54.467]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:54.467]                   ...future.conditions[[length(...future.conditions) + 
[01:28:54.467]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:54.467]                   if (TRUE && !signal) {
[01:28:54.467]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:54.467]                     {
[01:28:54.467]                       inherits <- base::inherits
[01:28:54.467]                       invokeRestart <- base::invokeRestart
[01:28:54.467]                       is.null <- base::is.null
[01:28:54.467]                       muffled <- FALSE
[01:28:54.467]                       if (inherits(cond, "message")) {
[01:28:54.467]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:54.467]                         if (muffled) 
[01:28:54.467]                           invokeRestart("muffleMessage")
[01:28:54.467]                       }
[01:28:54.467]                       else if (inherits(cond, "warning")) {
[01:28:54.467]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:54.467]                         if (muffled) 
[01:28:54.467]                           invokeRestart("muffleWarning")
[01:28:54.467]                       }
[01:28:54.467]                       else if (inherits(cond, "condition")) {
[01:28:54.467]                         if (!is.null(pattern)) {
[01:28:54.467]                           computeRestarts <- base::computeRestarts
[01:28:54.467]                           grepl <- base::grepl
[01:28:54.467]                           restarts <- computeRestarts(cond)
[01:28:54.467]                           for (restart in restarts) {
[01:28:54.467]                             name <- restart$name
[01:28:54.467]                             if (is.null(name)) 
[01:28:54.467]                               next
[01:28:54.467]                             if (!grepl(pattern, name)) 
[01:28:54.467]                               next
[01:28:54.467]                             invokeRestart(restart)
[01:28:54.467]                             muffled <- TRUE
[01:28:54.467]                             break
[01:28:54.467]                           }
[01:28:54.467]                         }
[01:28:54.467]                       }
[01:28:54.467]                       invisible(muffled)
[01:28:54.467]                     }
[01:28:54.467]                     muffleCondition(cond, pattern = "^muffle")
[01:28:54.467]                   }
[01:28:54.467]                 }
[01:28:54.467]                 else {
[01:28:54.467]                   if (TRUE) {
[01:28:54.467]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:54.467]                     {
[01:28:54.467]                       inherits <- base::inherits
[01:28:54.467]                       invokeRestart <- base::invokeRestart
[01:28:54.467]                       is.null <- base::is.null
[01:28:54.467]                       muffled <- FALSE
[01:28:54.467]                       if (inherits(cond, "message")) {
[01:28:54.467]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:54.467]                         if (muffled) 
[01:28:54.467]                           invokeRestart("muffleMessage")
[01:28:54.467]                       }
[01:28:54.467]                       else if (inherits(cond, "warning")) {
[01:28:54.467]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:54.467]                         if (muffled) 
[01:28:54.467]                           invokeRestart("muffleWarning")
[01:28:54.467]                       }
[01:28:54.467]                       else if (inherits(cond, "condition")) {
[01:28:54.467]                         if (!is.null(pattern)) {
[01:28:54.467]                           computeRestarts <- base::computeRestarts
[01:28:54.467]                           grepl <- base::grepl
[01:28:54.467]                           restarts <- computeRestarts(cond)
[01:28:54.467]                           for (restart in restarts) {
[01:28:54.467]                             name <- restart$name
[01:28:54.467]                             if (is.null(name)) 
[01:28:54.467]                               next
[01:28:54.467]                             if (!grepl(pattern, name)) 
[01:28:54.467]                               next
[01:28:54.467]                             invokeRestart(restart)
[01:28:54.467]                             muffled <- TRUE
[01:28:54.467]                             break
[01:28:54.467]                           }
[01:28:54.467]                         }
[01:28:54.467]                       }
[01:28:54.467]                       invisible(muffled)
[01:28:54.467]                     }
[01:28:54.467]                     muffleCondition(cond, pattern = "^muffle")
[01:28:54.467]                   }
[01:28:54.467]                 }
[01:28:54.467]             }
[01:28:54.467]         }))
[01:28:54.467]     }, error = function(ex) {
[01:28:54.467]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:54.467]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:54.467]                 ...future.rng), started = ...future.startTime, 
[01:28:54.467]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:54.467]             version = "1.8"), class = "FutureResult")
[01:28:54.467]     }, finally = {
[01:28:54.467]         if (!identical(...future.workdir, getwd())) 
[01:28:54.467]             setwd(...future.workdir)
[01:28:54.467]         {
[01:28:54.467]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:54.467]                 ...future.oldOptions$nwarnings <- NULL
[01:28:54.467]             }
[01:28:54.467]             base::options(...future.oldOptions)
[01:28:54.467]             if (.Platform$OS.type == "windows") {
[01:28:54.467]                 old_names <- names(...future.oldEnvVars)
[01:28:54.467]                 envs <- base::Sys.getenv()
[01:28:54.467]                 names <- names(envs)
[01:28:54.467]                 common <- intersect(names, old_names)
[01:28:54.467]                 added <- setdiff(names, old_names)
[01:28:54.467]                 removed <- setdiff(old_names, names)
[01:28:54.467]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:54.467]                   envs[common]]
[01:28:54.467]                 NAMES <- toupper(changed)
[01:28:54.467]                 args <- list()
[01:28:54.467]                 for (kk in seq_along(NAMES)) {
[01:28:54.467]                   name <- changed[[kk]]
[01:28:54.467]                   NAME <- NAMES[[kk]]
[01:28:54.467]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.467]                     next
[01:28:54.467]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:54.467]                 }
[01:28:54.467]                 NAMES <- toupper(added)
[01:28:54.467]                 for (kk in seq_along(NAMES)) {
[01:28:54.467]                   name <- added[[kk]]
[01:28:54.467]                   NAME <- NAMES[[kk]]
[01:28:54.467]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.467]                     next
[01:28:54.467]                   args[[name]] <- ""
[01:28:54.467]                 }
[01:28:54.467]                 NAMES <- toupper(removed)
[01:28:54.467]                 for (kk in seq_along(NAMES)) {
[01:28:54.467]                   name <- removed[[kk]]
[01:28:54.467]                   NAME <- NAMES[[kk]]
[01:28:54.467]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.467]                     next
[01:28:54.467]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:54.467]                 }
[01:28:54.467]                 if (length(args) > 0) 
[01:28:54.467]                   base::do.call(base::Sys.setenv, args = args)
[01:28:54.467]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:54.467]             }
[01:28:54.467]             else {
[01:28:54.467]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:54.467]             }
[01:28:54.467]             {
[01:28:54.467]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:54.467]                   0L) {
[01:28:54.467]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:54.467]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:54.467]                   base::options(opts)
[01:28:54.467]                 }
[01:28:54.467]                 {
[01:28:54.467]                   {
[01:28:54.467]                     NULL
[01:28:54.467]                     RNGkind("Mersenne-Twister")
[01:28:54.467]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:54.467]                       inherits = FALSE)
[01:28:54.467]                   }
[01:28:54.467]                   options(future.plan = NULL)
[01:28:54.467]                   if (is.na(NA_character_)) 
[01:28:54.467]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:54.467]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:54.467]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:54.467]                   {
[01:28:54.467]                     future <- SequentialFuture(..., envir = envir)
[01:28:54.467]                     if (!future$lazy) 
[01:28:54.467]                       future <- run(future)
[01:28:54.467]                     invisible(future)
[01:28:54.467]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:54.467]                 }
[01:28:54.467]             }
[01:28:54.467]         }
[01:28:54.467]     })
[01:28:54.467]     if (TRUE) {
[01:28:54.467]         base::sink(type = "output", split = FALSE)
[01:28:54.467]         if (TRUE) {
[01:28:54.467]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:54.467]         }
[01:28:54.467]         else {
[01:28:54.467]             ...future.result["stdout"] <- base::list(NULL)
[01:28:54.467]         }
[01:28:54.467]         base::close(...future.stdout)
[01:28:54.467]         ...future.stdout <- NULL
[01:28:54.467]     }
[01:28:54.467]     ...future.result$conditions <- ...future.conditions
[01:28:54.467]     ...future.result$finished <- base::Sys.time()
[01:28:54.467]     ...future.result
[01:28:54.467] }
[01:28:54.471] plan(): Setting new future strategy stack:
[01:28:54.471] List of future strategies:
[01:28:54.471] 1. sequential:
[01:28:54.471]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:54.471]    - tweaked: FALSE
[01:28:54.471]    - call: NULL
[01:28:54.472] plan(): nbrOfWorkers() = 1
[01:28:54.473] plan(): Setting new future strategy stack:
[01:28:54.473] List of future strategies:
[01:28:54.473] 1. sequential:
[01:28:54.473]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:54.473]    - tweaked: FALSE
[01:28:54.473]    - call: plan(strategy)
[01:28:54.474] plan(): nbrOfWorkers() = 1
[01:28:54.474] SequentialFuture started (and completed)
[01:28:54.474] - Launch lazy future ... done
[01:28:54.474] run() for 'SequentialFuture' ... done
[01:28:54.475] resolve() on environment ...
[01:28:54.475]  recursive: 0
[01:28:54.476]  elements: [3] 'a'
[01:28:54.476] resolved() for 'SequentialFuture' ...
[01:28:54.476] - state: 'finished'
[01:28:54.477] - run: TRUE
[01:28:54.477] - result: 'FutureResult'
[01:28:54.477] resolved() for 'SequentialFuture' ... done
[01:28:54.477] Future #1
[01:28:54.477]  length: 2 (resolved future 1)
[01:28:54.477] resolved() for 'SequentialFuture' ...
[01:28:54.478] - state: 'finished'
[01:28:54.478] - run: TRUE
[01:28:54.478] - result: 'FutureResult'
[01:28:54.478] resolved() for 'SequentialFuture' ... done
[01:28:54.478] Future #2
[01:28:54.479]  length: 1 (resolved future 2)
[01:28:54.479]  length: 0 (resolved future 3)
[01:28:54.479] resolve() on environment ... DONE
[01:28:54.479] resolved() for 'SequentialFuture' ...
[01:28:54.479] - state: 'finished'
[01:28:54.479] - run: TRUE
[01:28:54.480] - result: 'FutureResult'
[01:28:54.480] resolved() for 'SequentialFuture' ... done
[01:28:54.480] resolve() on environment ...
[01:28:54.481]  recursive: 0
[01:28:54.481]  elements: [3] 'b'
[01:28:54.481] resolved() for 'SequentialFuture' ...
[01:28:54.482] - state: 'finished'
[01:28:54.482] - run: TRUE
[01:28:54.482] - result: 'FutureResult'
[01:28:54.482] resolved() for 'SequentialFuture' ... done
[01:28:54.482] Future #1
[01:28:54.482]  length: 2 (resolved future 1)
[01:28:54.483] resolved() for 'SequentialFuture' ...
[01:28:54.483] - state: 'finished'
[01:28:54.483] - run: TRUE
[01:28:54.483] - result: 'FutureResult'
[01:28:54.483] resolved() for 'SequentialFuture' ... done
[01:28:54.484] Future #2
[01:28:54.484]  length: 1 (resolved future 2)
[01:28:54.484]  length: 0 (resolved future 3)
[01:28:54.484] resolve() on environment ... DONE
[01:28:54.485] resolve() on environment ...
[01:28:54.485]  recursive: 0
[01:28:54.485]  elements: [3] 'c'
[01:28:54.486] resolved() for 'SequentialFuture' ...
[01:28:54.486] - state: 'finished'
[01:28:54.486] - run: TRUE
[01:28:54.486] - result: 'FutureResult'
[01:28:54.486] resolved() for 'SequentialFuture' ... done
[01:28:54.487] Future #1
[01:28:54.487]  length: 2 (resolved future 1)
[01:28:54.487] resolved() for 'SequentialFuture' ...
[01:28:54.487] - state: 'finished'
[01:28:54.487] - run: TRUE
[01:28:54.487] - result: 'FutureResult'
[01:28:54.488] resolved() for 'SequentialFuture' ... done
[01:28:54.488] Future #2
[01:28:54.488]  length: 1 (resolved future 2)
[01:28:54.488]  length: 0 (resolved future 3)
[01:28:54.488] resolve() on environment ... DONE
[01:28:54.489] resolve() on environment ...
[01:28:54.489]  recursive: 0
[01:28:54.490]  elements: [3] 'a', 'b', 'c', '.future_b'
[01:28:54.490] resolved() for 'SequentialFuture' ...
[01:28:54.490] - state: 'finished'
[01:28:54.490] - run: TRUE
[01:28:54.490] - result: 'FutureResult'
[01:28:54.491] resolved() for 'SequentialFuture' ... done
[01:28:54.491] Future #1
[01:28:54.491]  length: 2 (resolved future 1)
[01:28:54.492] resolved() for 'SequentialFuture' ...
[01:28:54.492] - state: 'finished'
[01:28:54.492] - run: TRUE
[01:28:54.492] - result: 'FutureResult'
[01:28:54.492] resolved() for 'SequentialFuture' ... done
[01:28:54.492] Future #2
[01:28:54.493]  length: 1 (resolved future 2)
[01:28:54.493]  length: 0 (resolved future 3)
[01:28:54.493] resolve() on environment ... DONE
[01:28:54.494] resolve() on environment ...
[01:28:54.494]  recursive: 99
[01:28:54.494]  elements: [3] '.future_b', 'a', 'b', 'c'
[01:28:54.495] resolved() for 'SequentialFuture' ...
[01:28:54.495] - state: 'finished'
[01:28:54.495] - run: TRUE
[01:28:54.495] - result: 'FutureResult'
[01:28:54.495] resolved() for 'SequentialFuture' ... done
[01:28:54.496] Future #1
[01:28:54.496] resolved() for 'SequentialFuture' ...
[01:28:54.496] - state: 'finished'
[01:28:54.496] - run: TRUE
[01:28:54.496] - result: 'FutureResult'
[01:28:54.497] resolved() for 'SequentialFuture' ... done
[01:28:54.497] A SequentialFuture was resolved
[01:28:54.497]  length: 2 (resolved future 1)
[01:28:54.497] resolved() for 'SequentialFuture' ...
[01:28:54.497] - state: 'finished'
[01:28:54.498] - run: TRUE
[01:28:54.498] - result: 'FutureResult'
[01:28:54.498] resolved() for 'SequentialFuture' ... done
[01:28:54.523] Future #2
[01:28:54.524] resolved() for 'SequentialFuture' ...
[01:28:54.524] - state: 'finished'
[01:28:54.524] - run: TRUE
[01:28:54.524] - result: 'FutureResult'
[01:28:54.525] resolved() for 'SequentialFuture' ... done
[01:28:54.525] A SequentialFuture was resolved
[01:28:54.525]  length: 1 (resolved future 2)
[01:28:54.525]  length: 0 (resolved future 3)
[01:28:54.525] resolve() on environment ... DONE
*** resolve() for environments ... DONE
*** resolve() for list environments ...
[01:28:54.527] resolve() on list environment ...
[01:28:54.527]  recursive: 0
[01:28:54.528]  length: 2
[01:28:54.529]  elements: 'a', 'b'
[01:28:54.529]  length: 1 (resolved future 1)
[01:28:54.529]  length: 0 (resolved future 2)
[01:28:54.529] resolve() on list environment ... DONE
[01:28:54.529] getGlobalsAndPackages() ...
[01:28:54.530] Searching for globals...
[01:28:54.530] 
[01:28:54.530] Searching for globals ... DONE
[01:28:54.530] - globals: [0] <none>
[01:28:54.530] getGlobalsAndPackages() ... DONE
[01:28:54.531] run() for 'Future' ...
[01:28:54.531] - state: 'created'
[01:28:54.531] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:54.532] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:54.532] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:54.532]   - Field: 'label'
[01:28:54.532]   - Field: 'local'
[01:28:54.532]   - Field: 'owner'
[01:28:54.532]   - Field: 'envir'
[01:28:54.533]   - Field: 'packages'
[01:28:54.533]   - Field: 'gc'
[01:28:54.533]   - Field: 'conditions'
[01:28:54.533]   - Field: 'expr'
[01:28:54.533]   - Field: 'uuid'
[01:28:54.534]   - Field: 'seed'
[01:28:54.534]   - Field: 'version'
[01:28:54.534]   - Field: 'result'
[01:28:54.534]   - Field: 'asynchronous'
[01:28:54.534]   - Field: 'calls'
[01:28:54.534]   - Field: 'globals'
[01:28:54.535]   - Field: 'stdout'
[01:28:54.535]   - Field: 'earlySignal'
[01:28:54.535]   - Field: 'lazy'
[01:28:54.535]   - Field: 'state'
[01:28:54.535] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:54.535] - Launch lazy future ...
[01:28:54.536] Packages needed by the future expression (n = 0): <none>
[01:28:54.536] Packages needed by future strategies (n = 0): <none>
[01:28:54.537] {
[01:28:54.537]     {
[01:28:54.537]         {
[01:28:54.537]             ...future.startTime <- base::Sys.time()
[01:28:54.537]             {
[01:28:54.537]                 {
[01:28:54.537]                   {
[01:28:54.537]                     base::local({
[01:28:54.537]                       has_future <- base::requireNamespace("future", 
[01:28:54.537]                         quietly = TRUE)
[01:28:54.537]                       if (has_future) {
[01:28:54.537]                         ns <- base::getNamespace("future")
[01:28:54.537]                         version <- ns[[".package"]][["version"]]
[01:28:54.537]                         if (is.null(version)) 
[01:28:54.537]                           version <- utils::packageVersion("future")
[01:28:54.537]                       }
[01:28:54.537]                       else {
[01:28:54.537]                         version <- NULL
[01:28:54.537]                       }
[01:28:54.537]                       if (!has_future || version < "1.8.0") {
[01:28:54.537]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:54.537]                           "", base::R.version$version.string), 
[01:28:54.537]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:54.537]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:54.537]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:54.537]                             "release", "version")], collapse = " "), 
[01:28:54.537]                           hostname = base::Sys.info()[["nodename"]])
[01:28:54.537]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:54.537]                           info)
[01:28:54.537]                         info <- base::paste(info, collapse = "; ")
[01:28:54.537]                         if (!has_future) {
[01:28:54.537]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:54.537]                             info)
[01:28:54.537]                         }
[01:28:54.537]                         else {
[01:28:54.537]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:54.537]                             info, version)
[01:28:54.537]                         }
[01:28:54.537]                         base::stop(msg)
[01:28:54.537]                       }
[01:28:54.537]                     })
[01:28:54.537]                   }
[01:28:54.537]                   options(future.plan = NULL)
[01:28:54.537]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:54.537]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:54.537]                 }
[01:28:54.537]                 ...future.workdir <- getwd()
[01:28:54.537]             }
[01:28:54.537]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:54.537]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:54.537]         }
[01:28:54.537]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:54.537]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:54.537]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:54.537]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:54.537]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:54.537]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:54.537]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:54.537]             base::names(...future.oldOptions))
[01:28:54.537]     }
[01:28:54.537]     if (FALSE) {
[01:28:54.537]     }
[01:28:54.537]     else {
[01:28:54.537]         if (TRUE) {
[01:28:54.537]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:54.537]                 open = "w")
[01:28:54.537]         }
[01:28:54.537]         else {
[01:28:54.537]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:54.537]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:54.537]         }
[01:28:54.537]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:54.537]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:54.537]             base::sink(type = "output", split = FALSE)
[01:28:54.537]             base::close(...future.stdout)
[01:28:54.537]         }, add = TRUE)
[01:28:54.537]     }
[01:28:54.537]     ...future.frame <- base::sys.nframe()
[01:28:54.537]     ...future.conditions <- base::list()
[01:28:54.537]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:54.537]     if (FALSE) {
[01:28:54.537]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:54.537]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:54.537]     }
[01:28:54.537]     ...future.result <- base::tryCatch({
[01:28:54.537]         base::withCallingHandlers({
[01:28:54.537]             ...future.value <- base::withVisible(base::local(1))
[01:28:54.537]             future::FutureResult(value = ...future.value$value, 
[01:28:54.537]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:54.537]                   ...future.rng), globalenv = if (FALSE) 
[01:28:54.537]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:54.537]                     ...future.globalenv.names))
[01:28:54.537]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:54.537]         }, condition = base::local({
[01:28:54.537]             c <- base::c
[01:28:54.537]             inherits <- base::inherits
[01:28:54.537]             invokeRestart <- base::invokeRestart
[01:28:54.537]             length <- base::length
[01:28:54.537]             list <- base::list
[01:28:54.537]             seq.int <- base::seq.int
[01:28:54.537]             signalCondition <- base::signalCondition
[01:28:54.537]             sys.calls <- base::sys.calls
[01:28:54.537]             `[[` <- base::`[[`
[01:28:54.537]             `+` <- base::`+`
[01:28:54.537]             `<<-` <- base::`<<-`
[01:28:54.537]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:54.537]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:54.537]                   3L)]
[01:28:54.537]             }
[01:28:54.537]             function(cond) {
[01:28:54.537]                 is_error <- inherits(cond, "error")
[01:28:54.537]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:54.537]                   NULL)
[01:28:54.537]                 if (is_error) {
[01:28:54.537]                   sessionInformation <- function() {
[01:28:54.537]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:54.537]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:54.537]                       search = base::search(), system = base::Sys.info())
[01:28:54.537]                   }
[01:28:54.537]                   ...future.conditions[[length(...future.conditions) + 
[01:28:54.537]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:54.537]                     cond$call), session = sessionInformation(), 
[01:28:54.537]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:54.537]                   signalCondition(cond)
[01:28:54.537]                 }
[01:28:54.537]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:54.537]                 "immediateCondition"))) {
[01:28:54.537]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:54.537]                   ...future.conditions[[length(...future.conditions) + 
[01:28:54.537]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:54.537]                   if (TRUE && !signal) {
[01:28:54.537]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:54.537]                     {
[01:28:54.537]                       inherits <- base::inherits
[01:28:54.537]                       invokeRestart <- base::invokeRestart
[01:28:54.537]                       is.null <- base::is.null
[01:28:54.537]                       muffled <- FALSE
[01:28:54.537]                       if (inherits(cond, "message")) {
[01:28:54.537]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:54.537]                         if (muffled) 
[01:28:54.537]                           invokeRestart("muffleMessage")
[01:28:54.537]                       }
[01:28:54.537]                       else if (inherits(cond, "warning")) {
[01:28:54.537]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:54.537]                         if (muffled) 
[01:28:54.537]                           invokeRestart("muffleWarning")
[01:28:54.537]                       }
[01:28:54.537]                       else if (inherits(cond, "condition")) {
[01:28:54.537]                         if (!is.null(pattern)) {
[01:28:54.537]                           computeRestarts <- base::computeRestarts
[01:28:54.537]                           grepl <- base::grepl
[01:28:54.537]                           restarts <- computeRestarts(cond)
[01:28:54.537]                           for (restart in restarts) {
[01:28:54.537]                             name <- restart$name
[01:28:54.537]                             if (is.null(name)) 
[01:28:54.537]                               next
[01:28:54.537]                             if (!grepl(pattern, name)) 
[01:28:54.537]                               next
[01:28:54.537]                             invokeRestart(restart)
[01:28:54.537]                             muffled <- TRUE
[01:28:54.537]                             break
[01:28:54.537]                           }
[01:28:54.537]                         }
[01:28:54.537]                       }
[01:28:54.537]                       invisible(muffled)
[01:28:54.537]                     }
[01:28:54.537]                     muffleCondition(cond, pattern = "^muffle")
[01:28:54.537]                   }
[01:28:54.537]                 }
[01:28:54.537]                 else {
[01:28:54.537]                   if (TRUE) {
[01:28:54.537]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:54.537]                     {
[01:28:54.537]                       inherits <- base::inherits
[01:28:54.537]                       invokeRestart <- base::invokeRestart
[01:28:54.537]                       is.null <- base::is.null
[01:28:54.537]                       muffled <- FALSE
[01:28:54.537]                       if (inherits(cond, "message")) {
[01:28:54.537]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:54.537]                         if (muffled) 
[01:28:54.537]                           invokeRestart("muffleMessage")
[01:28:54.537]                       }
[01:28:54.537]                       else if (inherits(cond, "warning")) {
[01:28:54.537]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:54.537]                         if (muffled) 
[01:28:54.537]                           invokeRestart("muffleWarning")
[01:28:54.537]                       }
[01:28:54.537]                       else if (inherits(cond, "condition")) {
[01:28:54.537]                         if (!is.null(pattern)) {
[01:28:54.537]                           computeRestarts <- base::computeRestarts
[01:28:54.537]                           grepl <- base::grepl
[01:28:54.537]                           restarts <- computeRestarts(cond)
[01:28:54.537]                           for (restart in restarts) {
[01:28:54.537]                             name <- restart$name
[01:28:54.537]                             if (is.null(name)) 
[01:28:54.537]                               next
[01:28:54.537]                             if (!grepl(pattern, name)) 
[01:28:54.537]                               next
[01:28:54.537]                             invokeRestart(restart)
[01:28:54.537]                             muffled <- TRUE
[01:28:54.537]                             break
[01:28:54.537]                           }
[01:28:54.537]                         }
[01:28:54.537]                       }
[01:28:54.537]                       invisible(muffled)
[01:28:54.537]                     }
[01:28:54.537]                     muffleCondition(cond, pattern = "^muffle")
[01:28:54.537]                   }
[01:28:54.537]                 }
[01:28:54.537]             }
[01:28:54.537]         }))
[01:28:54.537]     }, error = function(ex) {
[01:28:54.537]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:54.537]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:54.537]                 ...future.rng), started = ...future.startTime, 
[01:28:54.537]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:54.537]             version = "1.8"), class = "FutureResult")
[01:28:54.537]     }, finally = {
[01:28:54.537]         if (!identical(...future.workdir, getwd())) 
[01:28:54.537]             setwd(...future.workdir)
[01:28:54.537]         {
[01:28:54.537]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:54.537]                 ...future.oldOptions$nwarnings <- NULL
[01:28:54.537]             }
[01:28:54.537]             base::options(...future.oldOptions)
[01:28:54.537]             if (.Platform$OS.type == "windows") {
[01:28:54.537]                 old_names <- names(...future.oldEnvVars)
[01:28:54.537]                 envs <- base::Sys.getenv()
[01:28:54.537]                 names <- names(envs)
[01:28:54.537]                 common <- intersect(names, old_names)
[01:28:54.537]                 added <- setdiff(names, old_names)
[01:28:54.537]                 removed <- setdiff(old_names, names)
[01:28:54.537]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:54.537]                   envs[common]]
[01:28:54.537]                 NAMES <- toupper(changed)
[01:28:54.537]                 args <- list()
[01:28:54.537]                 for (kk in seq_along(NAMES)) {
[01:28:54.537]                   name <- changed[[kk]]
[01:28:54.537]                   NAME <- NAMES[[kk]]
[01:28:54.537]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.537]                     next
[01:28:54.537]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:54.537]                 }
[01:28:54.537]                 NAMES <- toupper(added)
[01:28:54.537]                 for (kk in seq_along(NAMES)) {
[01:28:54.537]                   name <- added[[kk]]
[01:28:54.537]                   NAME <- NAMES[[kk]]
[01:28:54.537]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.537]                     next
[01:28:54.537]                   args[[name]] <- ""
[01:28:54.537]                 }
[01:28:54.537]                 NAMES <- toupper(removed)
[01:28:54.537]                 for (kk in seq_along(NAMES)) {
[01:28:54.537]                   name <- removed[[kk]]
[01:28:54.537]                   NAME <- NAMES[[kk]]
[01:28:54.537]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.537]                     next
[01:28:54.537]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:54.537]                 }
[01:28:54.537]                 if (length(args) > 0) 
[01:28:54.537]                   base::do.call(base::Sys.setenv, args = args)
[01:28:54.537]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:54.537]             }
[01:28:54.537]             else {
[01:28:54.537]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:54.537]             }
[01:28:54.537]             {
[01:28:54.537]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:54.537]                   0L) {
[01:28:54.537]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:54.537]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:54.537]                   base::options(opts)
[01:28:54.537]                 }
[01:28:54.537]                 {
[01:28:54.537]                   {
[01:28:54.537]                     NULL
[01:28:54.537]                     RNGkind("Mersenne-Twister")
[01:28:54.537]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:54.537]                       inherits = FALSE)
[01:28:54.537]                   }
[01:28:54.537]                   options(future.plan = NULL)
[01:28:54.537]                   if (is.na(NA_character_)) 
[01:28:54.537]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:54.537]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:54.537]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:54.537]                   {
[01:28:54.537]                     future <- SequentialFuture(..., envir = envir)
[01:28:54.537]                     if (!future$lazy) 
[01:28:54.537]                       future <- run(future)
[01:28:54.537]                     invisible(future)
[01:28:54.537]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:54.537]                 }
[01:28:54.537]             }
[01:28:54.537]         }
[01:28:54.537]     })
[01:28:54.537]     if (TRUE) {
[01:28:54.537]         base::sink(type = "output", split = FALSE)
[01:28:54.537]         if (TRUE) {
[01:28:54.537]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:54.537]         }
[01:28:54.537]         else {
[01:28:54.537]             ...future.result["stdout"] <- base::list(NULL)
[01:28:54.537]         }
[01:28:54.537]         base::close(...future.stdout)
[01:28:54.537]         ...future.stdout <- NULL
[01:28:54.537]     }
[01:28:54.537]     ...future.result$conditions <- ...future.conditions
[01:28:54.537]     ...future.result$finished <- base::Sys.time()
[01:28:54.537]     ...future.result
[01:28:54.537] }
[01:28:54.540] plan(): Setting new future strategy stack:
[01:28:54.541] List of future strategies:
[01:28:54.541] 1. sequential:
[01:28:54.541]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:54.541]    - tweaked: FALSE
[01:28:54.541]    - call: NULL
[01:28:54.541] plan(): nbrOfWorkers() = 1
[01:28:54.542] plan(): Setting new future strategy stack:
[01:28:54.543] List of future strategies:
[01:28:54.543] 1. sequential:
[01:28:54.543]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:54.543]    - tweaked: FALSE
[01:28:54.543]    - call: plan(strategy)
[01:28:54.543] plan(): nbrOfWorkers() = 1
[01:28:54.543] SequentialFuture started (and completed)
[01:28:54.544] - Launch lazy future ... done
[01:28:54.544] run() for 'SequentialFuture' ... done
[01:28:54.544] getGlobalsAndPackages() ...
[01:28:54.544] Searching for globals...
[01:28:54.545] 
[01:28:54.545] Searching for globals ... DONE
[01:28:54.545] - globals: [0] <none>
[01:28:54.545] getGlobalsAndPackages() ... DONE
[01:28:54.545] run() for 'Future' ...
[01:28:54.546] - state: 'created'
[01:28:54.546] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:54.546] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:54.546] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:54.547]   - Field: 'label'
[01:28:54.547]   - Field: 'local'
[01:28:54.547]   - Field: 'owner'
[01:28:54.547]   - Field: 'envir'
[01:28:54.547]   - Field: 'packages'
[01:28:54.548]   - Field: 'gc'
[01:28:54.548]   - Field: 'conditions'
[01:28:54.548]   - Field: 'expr'
[01:28:54.548]   - Field: 'uuid'
[01:28:54.548]   - Field: 'seed'
[01:28:54.548]   - Field: 'version'
[01:28:54.549]   - Field: 'result'
[01:28:54.549]   - Field: 'asynchronous'
[01:28:54.549]   - Field: 'calls'
[01:28:54.549]   - Field: 'globals'
[01:28:54.549]   - Field: 'stdout'
[01:28:54.549]   - Field: 'earlySignal'
[01:28:54.550]   - Field: 'lazy'
[01:28:54.550]   - Field: 'state'
[01:28:54.550] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:54.550] - Launch lazy future ...
[01:28:54.550] Packages needed by the future expression (n = 0): <none>
[01:28:54.551] Packages needed by future strategies (n = 0): <none>
[01:28:54.551] {
[01:28:54.551]     {
[01:28:54.551]         {
[01:28:54.551]             ...future.startTime <- base::Sys.time()
[01:28:54.551]             {
[01:28:54.551]                 {
[01:28:54.551]                   {
[01:28:54.551]                     base::local({
[01:28:54.551]                       has_future <- base::requireNamespace("future", 
[01:28:54.551]                         quietly = TRUE)
[01:28:54.551]                       if (has_future) {
[01:28:54.551]                         ns <- base::getNamespace("future")
[01:28:54.551]                         version <- ns[[".package"]][["version"]]
[01:28:54.551]                         if (is.null(version)) 
[01:28:54.551]                           version <- utils::packageVersion("future")
[01:28:54.551]                       }
[01:28:54.551]                       else {
[01:28:54.551]                         version <- NULL
[01:28:54.551]                       }
[01:28:54.551]                       if (!has_future || version < "1.8.0") {
[01:28:54.551]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:54.551]                           "", base::R.version$version.string), 
[01:28:54.551]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:54.551]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:54.551]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:54.551]                             "release", "version")], collapse = " "), 
[01:28:54.551]                           hostname = base::Sys.info()[["nodename"]])
[01:28:54.551]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:54.551]                           info)
[01:28:54.551]                         info <- base::paste(info, collapse = "; ")
[01:28:54.551]                         if (!has_future) {
[01:28:54.551]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:54.551]                             info)
[01:28:54.551]                         }
[01:28:54.551]                         else {
[01:28:54.551]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:54.551]                             info, version)
[01:28:54.551]                         }
[01:28:54.551]                         base::stop(msg)
[01:28:54.551]                       }
[01:28:54.551]                     })
[01:28:54.551]                   }
[01:28:54.551]                   options(future.plan = NULL)
[01:28:54.551]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:54.551]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:54.551]                 }
[01:28:54.551]                 ...future.workdir <- getwd()
[01:28:54.551]             }
[01:28:54.551]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:54.551]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:54.551]         }
[01:28:54.551]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:54.551]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:54.551]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:54.551]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:54.551]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:54.551]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:54.551]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:54.551]             base::names(...future.oldOptions))
[01:28:54.551]     }
[01:28:54.551]     if (FALSE) {
[01:28:54.551]     }
[01:28:54.551]     else {
[01:28:54.551]         if (TRUE) {
[01:28:54.551]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:54.551]                 open = "w")
[01:28:54.551]         }
[01:28:54.551]         else {
[01:28:54.551]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:54.551]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:54.551]         }
[01:28:54.551]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:54.551]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:54.551]             base::sink(type = "output", split = FALSE)
[01:28:54.551]             base::close(...future.stdout)
[01:28:54.551]         }, add = TRUE)
[01:28:54.551]     }
[01:28:54.551]     ...future.frame <- base::sys.nframe()
[01:28:54.551]     ...future.conditions <- base::list()
[01:28:54.551]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:54.551]     if (FALSE) {
[01:28:54.551]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:54.551]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:54.551]     }
[01:28:54.551]     ...future.result <- base::tryCatch({
[01:28:54.551]         base::withCallingHandlers({
[01:28:54.551]             ...future.value <- base::withVisible(base::local(2))
[01:28:54.551]             future::FutureResult(value = ...future.value$value, 
[01:28:54.551]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:54.551]                   ...future.rng), globalenv = if (FALSE) 
[01:28:54.551]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:54.551]                     ...future.globalenv.names))
[01:28:54.551]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:54.551]         }, condition = base::local({
[01:28:54.551]             c <- base::c
[01:28:54.551]             inherits <- base::inherits
[01:28:54.551]             invokeRestart <- base::invokeRestart
[01:28:54.551]             length <- base::length
[01:28:54.551]             list <- base::list
[01:28:54.551]             seq.int <- base::seq.int
[01:28:54.551]             signalCondition <- base::signalCondition
[01:28:54.551]             sys.calls <- base::sys.calls
[01:28:54.551]             `[[` <- base::`[[`
[01:28:54.551]             `+` <- base::`+`
[01:28:54.551]             `<<-` <- base::`<<-`
[01:28:54.551]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:54.551]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:54.551]                   3L)]
[01:28:54.551]             }
[01:28:54.551]             function(cond) {
[01:28:54.551]                 is_error <- inherits(cond, "error")
[01:28:54.551]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:54.551]                   NULL)
[01:28:54.551]                 if (is_error) {
[01:28:54.551]                   sessionInformation <- function() {
[01:28:54.551]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:54.551]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:54.551]                       search = base::search(), system = base::Sys.info())
[01:28:54.551]                   }
[01:28:54.551]                   ...future.conditions[[length(...future.conditions) + 
[01:28:54.551]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:54.551]                     cond$call), session = sessionInformation(), 
[01:28:54.551]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:54.551]                   signalCondition(cond)
[01:28:54.551]                 }
[01:28:54.551]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:54.551]                 "immediateCondition"))) {
[01:28:54.551]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:54.551]                   ...future.conditions[[length(...future.conditions) + 
[01:28:54.551]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:54.551]                   if (TRUE && !signal) {
[01:28:54.551]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:54.551]                     {
[01:28:54.551]                       inherits <- base::inherits
[01:28:54.551]                       invokeRestart <- base::invokeRestart
[01:28:54.551]                       is.null <- base::is.null
[01:28:54.551]                       muffled <- FALSE
[01:28:54.551]                       if (inherits(cond, "message")) {
[01:28:54.551]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:54.551]                         if (muffled) 
[01:28:54.551]                           invokeRestart("muffleMessage")
[01:28:54.551]                       }
[01:28:54.551]                       else if (inherits(cond, "warning")) {
[01:28:54.551]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:54.551]                         if (muffled) 
[01:28:54.551]                           invokeRestart("muffleWarning")
[01:28:54.551]                       }
[01:28:54.551]                       else if (inherits(cond, "condition")) {
[01:28:54.551]                         if (!is.null(pattern)) {
[01:28:54.551]                           computeRestarts <- base::computeRestarts
[01:28:54.551]                           grepl <- base::grepl
[01:28:54.551]                           restarts <- computeRestarts(cond)
[01:28:54.551]                           for (restart in restarts) {
[01:28:54.551]                             name <- restart$name
[01:28:54.551]                             if (is.null(name)) 
[01:28:54.551]                               next
[01:28:54.551]                             if (!grepl(pattern, name)) 
[01:28:54.551]                               next
[01:28:54.551]                             invokeRestart(restart)
[01:28:54.551]                             muffled <- TRUE
[01:28:54.551]                             break
[01:28:54.551]                           }
[01:28:54.551]                         }
[01:28:54.551]                       }
[01:28:54.551]                       invisible(muffled)
[01:28:54.551]                     }
[01:28:54.551]                     muffleCondition(cond, pattern = "^muffle")
[01:28:54.551]                   }
[01:28:54.551]                 }
[01:28:54.551]                 else {
[01:28:54.551]                   if (TRUE) {
[01:28:54.551]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:54.551]                     {
[01:28:54.551]                       inherits <- base::inherits
[01:28:54.551]                       invokeRestart <- base::invokeRestart
[01:28:54.551]                       is.null <- base::is.null
[01:28:54.551]                       muffled <- FALSE
[01:28:54.551]                       if (inherits(cond, "message")) {
[01:28:54.551]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:54.551]                         if (muffled) 
[01:28:54.551]                           invokeRestart("muffleMessage")
[01:28:54.551]                       }
[01:28:54.551]                       else if (inherits(cond, "warning")) {
[01:28:54.551]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:54.551]                         if (muffled) 
[01:28:54.551]                           invokeRestart("muffleWarning")
[01:28:54.551]                       }
[01:28:54.551]                       else if (inherits(cond, "condition")) {
[01:28:54.551]                         if (!is.null(pattern)) {
[01:28:54.551]                           computeRestarts <- base::computeRestarts
[01:28:54.551]                           grepl <- base::grepl
[01:28:54.551]                           restarts <- computeRestarts(cond)
[01:28:54.551]                           for (restart in restarts) {
[01:28:54.551]                             name <- restart$name
[01:28:54.551]                             if (is.null(name)) 
[01:28:54.551]                               next
[01:28:54.551]                             if (!grepl(pattern, name)) 
[01:28:54.551]                               next
[01:28:54.551]                             invokeRestart(restart)
[01:28:54.551]                             muffled <- TRUE
[01:28:54.551]                             break
[01:28:54.551]                           }
[01:28:54.551]                         }
[01:28:54.551]                       }
[01:28:54.551]                       invisible(muffled)
[01:28:54.551]                     }
[01:28:54.551]                     muffleCondition(cond, pattern = "^muffle")
[01:28:54.551]                   }
[01:28:54.551]                 }
[01:28:54.551]             }
[01:28:54.551]         }))
[01:28:54.551]     }, error = function(ex) {
[01:28:54.551]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:54.551]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:54.551]                 ...future.rng), started = ...future.startTime, 
[01:28:54.551]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:54.551]             version = "1.8"), class = "FutureResult")
[01:28:54.551]     }, finally = {
[01:28:54.551]         if (!identical(...future.workdir, getwd())) 
[01:28:54.551]             setwd(...future.workdir)
[01:28:54.551]         {
[01:28:54.551]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:54.551]                 ...future.oldOptions$nwarnings <- NULL
[01:28:54.551]             }
[01:28:54.551]             base::options(...future.oldOptions)
[01:28:54.551]             if (.Platform$OS.type == "windows") {
[01:28:54.551]                 old_names <- names(...future.oldEnvVars)
[01:28:54.551]                 envs <- base::Sys.getenv()
[01:28:54.551]                 names <- names(envs)
[01:28:54.551]                 common <- intersect(names, old_names)
[01:28:54.551]                 added <- setdiff(names, old_names)
[01:28:54.551]                 removed <- setdiff(old_names, names)
[01:28:54.551]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:54.551]                   envs[common]]
[01:28:54.551]                 NAMES <- toupper(changed)
[01:28:54.551]                 args <- list()
[01:28:54.551]                 for (kk in seq_along(NAMES)) {
[01:28:54.551]                   name <- changed[[kk]]
[01:28:54.551]                   NAME <- NAMES[[kk]]
[01:28:54.551]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.551]                     next
[01:28:54.551]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:54.551]                 }
[01:28:54.551]                 NAMES <- toupper(added)
[01:28:54.551]                 for (kk in seq_along(NAMES)) {
[01:28:54.551]                   name <- added[[kk]]
[01:28:54.551]                   NAME <- NAMES[[kk]]
[01:28:54.551]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.551]                     next
[01:28:54.551]                   args[[name]] <- ""
[01:28:54.551]                 }
[01:28:54.551]                 NAMES <- toupper(removed)
[01:28:54.551]                 for (kk in seq_along(NAMES)) {
[01:28:54.551]                   name <- removed[[kk]]
[01:28:54.551]                   NAME <- NAMES[[kk]]
[01:28:54.551]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.551]                     next
[01:28:54.551]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:54.551]                 }
[01:28:54.551]                 if (length(args) > 0) 
[01:28:54.551]                   base::do.call(base::Sys.setenv, args = args)
[01:28:54.551]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:54.551]             }
[01:28:54.551]             else {
[01:28:54.551]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:54.551]             }
[01:28:54.551]             {
[01:28:54.551]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:54.551]                   0L) {
[01:28:54.551]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:54.551]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:54.551]                   base::options(opts)
[01:28:54.551]                 }
[01:28:54.551]                 {
[01:28:54.551]                   {
[01:28:54.551]                     NULL
[01:28:54.551]                     RNGkind("Mersenne-Twister")
[01:28:54.551]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:54.551]                       inherits = FALSE)
[01:28:54.551]                   }
[01:28:54.551]                   options(future.plan = NULL)
[01:28:54.551]                   if (is.na(NA_character_)) 
[01:28:54.551]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:54.551]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:54.551]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:54.551]                   {
[01:28:54.551]                     future <- SequentialFuture(..., envir = envir)
[01:28:54.551]                     if (!future$lazy) 
[01:28:54.551]                       future <- run(future)
[01:28:54.551]                     invisible(future)
[01:28:54.551]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:54.551]                 }
[01:28:54.551]             }
[01:28:54.551]         }
[01:28:54.551]     })
[01:28:54.551]     if (TRUE) {
[01:28:54.551]         base::sink(type = "output", split = FALSE)
[01:28:54.551]         if (TRUE) {
[01:28:54.551]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:54.551]         }
[01:28:54.551]         else {
[01:28:54.551]             ...future.result["stdout"] <- base::list(NULL)
[01:28:54.551]         }
[01:28:54.551]         base::close(...future.stdout)
[01:28:54.551]         ...future.stdout <- NULL
[01:28:54.551]     }
[01:28:54.551]     ...future.result$conditions <- ...future.conditions
[01:28:54.551]     ...future.result$finished <- base::Sys.time()
[01:28:54.551]     ...future.result
[01:28:54.551] }
[01:28:54.555] plan(): Setting new future strategy stack:
[01:28:54.555] List of future strategies:
[01:28:54.555] 1. sequential:
[01:28:54.555]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:54.555]    - tweaked: FALSE
[01:28:54.555]    - call: NULL
[01:28:54.556] plan(): nbrOfWorkers() = 1
[01:28:54.557] plan(): Setting new future strategy stack:
[01:28:54.557] List of future strategies:
[01:28:54.557] 1. sequential:
[01:28:54.557]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:54.557]    - tweaked: FALSE
[01:28:54.557]    - call: plan(strategy)
[01:28:54.558] plan(): nbrOfWorkers() = 1
[01:28:54.558] SequentialFuture started (and completed)
[01:28:54.558] - Launch lazy future ... done
[01:28:54.558] run() for 'SequentialFuture' ... done
[01:28:54.559] resolve() on list environment ...
[01:28:54.559]  recursive: 0
[01:28:54.560]  length: 3
[01:28:54.560]  elements: 'a', 'b', 'c'
[01:28:54.560] resolved() for 'SequentialFuture' ...
[01:28:54.561] - state: 'finished'
[01:28:54.561] - run: TRUE
[01:28:54.561] - result: 'FutureResult'
[01:28:54.561] resolved() for 'SequentialFuture' ... done
[01:28:54.561] Future #1
[01:28:54.562]  length: 2 (resolved future 1)
[01:28:54.562] resolved() for 'SequentialFuture' ...
[01:28:54.562] - state: 'finished'
[01:28:54.562] - run: TRUE
[01:28:54.562] - result: 'FutureResult'
[01:28:54.563] resolved() for 'SequentialFuture' ... done
[01:28:54.563] Future #2
[01:28:54.563]  length: 1 (resolved future 2)
[01:28:54.563]  length: 0 (resolved future 3)
[01:28:54.563] resolve() on list environment ... DONE
[01:28:54.565] getGlobalsAndPackages() ...
[01:28:54.565] Searching for globals...
[01:28:54.566] - globals found: [1] '{'
[01:28:54.566] Searching for globals ... DONE
[01:28:54.567] Resolving globals: FALSE
[01:28:54.567] 
[01:28:54.567] 
[01:28:54.567] getGlobalsAndPackages() ... DONE
[01:28:54.568] run() for 'Future' ...
[01:28:54.568] - state: 'created'
[01:28:54.568] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:54.568] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:54.569] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:54.569]   - Field: 'label'
[01:28:54.569]   - Field: 'local'
[01:28:54.569]   - Field: 'owner'
[01:28:54.569]   - Field: 'envir'
[01:28:54.569]   - Field: 'packages'
[01:28:54.570]   - Field: 'gc'
[01:28:54.570]   - Field: 'conditions'
[01:28:54.570]   - Field: 'expr'
[01:28:54.570]   - Field: 'uuid'
[01:28:54.570]   - Field: 'seed'
[01:28:54.570]   - Field: 'version'
[01:28:54.571]   - Field: 'result'
[01:28:54.571]   - Field: 'asynchronous'
[01:28:54.571]   - Field: 'calls'
[01:28:54.571]   - Field: 'globals'
[01:28:54.571]   - Field: 'stdout'
[01:28:54.572]   - Field: 'earlySignal'
[01:28:54.572]   - Field: 'lazy'
[01:28:54.572]   - Field: 'state'
[01:28:54.572] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:54.572] - Launch lazy future ...
[01:28:54.572] Packages needed by the future expression (n = 0): <none>
[01:28:54.573] Packages needed by future strategies (n = 0): <none>
[01:28:54.573] {
[01:28:54.573]     {
[01:28:54.573]         {
[01:28:54.573]             ...future.startTime <- base::Sys.time()
[01:28:54.573]             {
[01:28:54.573]                 {
[01:28:54.573]                   {
[01:28:54.573]                     base::local({
[01:28:54.573]                       has_future <- base::requireNamespace("future", 
[01:28:54.573]                         quietly = TRUE)
[01:28:54.573]                       if (has_future) {
[01:28:54.573]                         ns <- base::getNamespace("future")
[01:28:54.573]                         version <- ns[[".package"]][["version"]]
[01:28:54.573]                         if (is.null(version)) 
[01:28:54.573]                           version <- utils::packageVersion("future")
[01:28:54.573]                       }
[01:28:54.573]                       else {
[01:28:54.573]                         version <- NULL
[01:28:54.573]                       }
[01:28:54.573]                       if (!has_future || version < "1.8.0") {
[01:28:54.573]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:54.573]                           "", base::R.version$version.string), 
[01:28:54.573]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:54.573]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:54.573]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:54.573]                             "release", "version")], collapse = " "), 
[01:28:54.573]                           hostname = base::Sys.info()[["nodename"]])
[01:28:54.573]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:54.573]                           info)
[01:28:54.573]                         info <- base::paste(info, collapse = "; ")
[01:28:54.573]                         if (!has_future) {
[01:28:54.573]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:54.573]                             info)
[01:28:54.573]                         }
[01:28:54.573]                         else {
[01:28:54.573]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:54.573]                             info, version)
[01:28:54.573]                         }
[01:28:54.573]                         base::stop(msg)
[01:28:54.573]                       }
[01:28:54.573]                     })
[01:28:54.573]                   }
[01:28:54.573]                   options(future.plan = NULL)
[01:28:54.573]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:54.573]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:54.573]                 }
[01:28:54.573]                 ...future.workdir <- getwd()
[01:28:54.573]             }
[01:28:54.573]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:54.573]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:54.573]         }
[01:28:54.573]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:54.573]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:54.573]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:54.573]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:54.573]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:54.573]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:54.573]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:54.573]             base::names(...future.oldOptions))
[01:28:54.573]     }
[01:28:54.573]     if (FALSE) {
[01:28:54.573]     }
[01:28:54.573]     else {
[01:28:54.573]         if (TRUE) {
[01:28:54.573]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:54.573]                 open = "w")
[01:28:54.573]         }
[01:28:54.573]         else {
[01:28:54.573]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:54.573]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:54.573]         }
[01:28:54.573]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:54.573]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:54.573]             base::sink(type = "output", split = FALSE)
[01:28:54.573]             base::close(...future.stdout)
[01:28:54.573]         }, add = TRUE)
[01:28:54.573]     }
[01:28:54.573]     ...future.frame <- base::sys.nframe()
[01:28:54.573]     ...future.conditions <- base::list()
[01:28:54.573]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:54.573]     if (FALSE) {
[01:28:54.573]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:54.573]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:54.573]     }
[01:28:54.573]     ...future.result <- base::tryCatch({
[01:28:54.573]         base::withCallingHandlers({
[01:28:54.573]             ...future.value <- base::withVisible(base::local({
[01:28:54.573]                 1
[01:28:54.573]             }))
[01:28:54.573]             future::FutureResult(value = ...future.value$value, 
[01:28:54.573]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:54.573]                   ...future.rng), globalenv = if (FALSE) 
[01:28:54.573]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:54.573]                     ...future.globalenv.names))
[01:28:54.573]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:54.573]         }, condition = base::local({
[01:28:54.573]             c <- base::c
[01:28:54.573]             inherits <- base::inherits
[01:28:54.573]             invokeRestart <- base::invokeRestart
[01:28:54.573]             length <- base::length
[01:28:54.573]             list <- base::list
[01:28:54.573]             seq.int <- base::seq.int
[01:28:54.573]             signalCondition <- base::signalCondition
[01:28:54.573]             sys.calls <- base::sys.calls
[01:28:54.573]             `[[` <- base::`[[`
[01:28:54.573]             `+` <- base::`+`
[01:28:54.573]             `<<-` <- base::`<<-`
[01:28:54.573]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:54.573]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:54.573]                   3L)]
[01:28:54.573]             }
[01:28:54.573]             function(cond) {
[01:28:54.573]                 is_error <- inherits(cond, "error")
[01:28:54.573]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:54.573]                   NULL)
[01:28:54.573]                 if (is_error) {
[01:28:54.573]                   sessionInformation <- function() {
[01:28:54.573]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:54.573]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:54.573]                       search = base::search(), system = base::Sys.info())
[01:28:54.573]                   }
[01:28:54.573]                   ...future.conditions[[length(...future.conditions) + 
[01:28:54.573]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:54.573]                     cond$call), session = sessionInformation(), 
[01:28:54.573]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:54.573]                   signalCondition(cond)
[01:28:54.573]                 }
[01:28:54.573]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:54.573]                 "immediateCondition"))) {
[01:28:54.573]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:54.573]                   ...future.conditions[[length(...future.conditions) + 
[01:28:54.573]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:54.573]                   if (TRUE && !signal) {
[01:28:54.573]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:54.573]                     {
[01:28:54.573]                       inherits <- base::inherits
[01:28:54.573]                       invokeRestart <- base::invokeRestart
[01:28:54.573]                       is.null <- base::is.null
[01:28:54.573]                       muffled <- FALSE
[01:28:54.573]                       if (inherits(cond, "message")) {
[01:28:54.573]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:54.573]                         if (muffled) 
[01:28:54.573]                           invokeRestart("muffleMessage")
[01:28:54.573]                       }
[01:28:54.573]                       else if (inherits(cond, "warning")) {
[01:28:54.573]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:54.573]                         if (muffled) 
[01:28:54.573]                           invokeRestart("muffleWarning")
[01:28:54.573]                       }
[01:28:54.573]                       else if (inherits(cond, "condition")) {
[01:28:54.573]                         if (!is.null(pattern)) {
[01:28:54.573]                           computeRestarts <- base::computeRestarts
[01:28:54.573]                           grepl <- base::grepl
[01:28:54.573]                           restarts <- computeRestarts(cond)
[01:28:54.573]                           for (restart in restarts) {
[01:28:54.573]                             name <- restart$name
[01:28:54.573]                             if (is.null(name)) 
[01:28:54.573]                               next
[01:28:54.573]                             if (!grepl(pattern, name)) 
[01:28:54.573]                               next
[01:28:54.573]                             invokeRestart(restart)
[01:28:54.573]                             muffled <- TRUE
[01:28:54.573]                             break
[01:28:54.573]                           }
[01:28:54.573]                         }
[01:28:54.573]                       }
[01:28:54.573]                       invisible(muffled)
[01:28:54.573]                     }
[01:28:54.573]                     muffleCondition(cond, pattern = "^muffle")
[01:28:54.573]                   }
[01:28:54.573]                 }
[01:28:54.573]                 else {
[01:28:54.573]                   if (TRUE) {
[01:28:54.573]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:54.573]                     {
[01:28:54.573]                       inherits <- base::inherits
[01:28:54.573]                       invokeRestart <- base::invokeRestart
[01:28:54.573]                       is.null <- base::is.null
[01:28:54.573]                       muffled <- FALSE
[01:28:54.573]                       if (inherits(cond, "message")) {
[01:28:54.573]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:54.573]                         if (muffled) 
[01:28:54.573]                           invokeRestart("muffleMessage")
[01:28:54.573]                       }
[01:28:54.573]                       else if (inherits(cond, "warning")) {
[01:28:54.573]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:54.573]                         if (muffled) 
[01:28:54.573]                           invokeRestart("muffleWarning")
[01:28:54.573]                       }
[01:28:54.573]                       else if (inherits(cond, "condition")) {
[01:28:54.573]                         if (!is.null(pattern)) {
[01:28:54.573]                           computeRestarts <- base::computeRestarts
[01:28:54.573]                           grepl <- base::grepl
[01:28:54.573]                           restarts <- computeRestarts(cond)
[01:28:54.573]                           for (restart in restarts) {
[01:28:54.573]                             name <- restart$name
[01:28:54.573]                             if (is.null(name)) 
[01:28:54.573]                               next
[01:28:54.573]                             if (!grepl(pattern, name)) 
[01:28:54.573]                               next
[01:28:54.573]                             invokeRestart(restart)
[01:28:54.573]                             muffled <- TRUE
[01:28:54.573]                             break
[01:28:54.573]                           }
[01:28:54.573]                         }
[01:28:54.573]                       }
[01:28:54.573]                       invisible(muffled)
[01:28:54.573]                     }
[01:28:54.573]                     muffleCondition(cond, pattern = "^muffle")
[01:28:54.573]                   }
[01:28:54.573]                 }
[01:28:54.573]             }
[01:28:54.573]         }))
[01:28:54.573]     }, error = function(ex) {
[01:28:54.573]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:54.573]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:54.573]                 ...future.rng), started = ...future.startTime, 
[01:28:54.573]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:54.573]             version = "1.8"), class = "FutureResult")
[01:28:54.573]     }, finally = {
[01:28:54.573]         if (!identical(...future.workdir, getwd())) 
[01:28:54.573]             setwd(...future.workdir)
[01:28:54.573]         {
[01:28:54.573]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:54.573]                 ...future.oldOptions$nwarnings <- NULL
[01:28:54.573]             }
[01:28:54.573]             base::options(...future.oldOptions)
[01:28:54.573]             if (.Platform$OS.type == "windows") {
[01:28:54.573]                 old_names <- names(...future.oldEnvVars)
[01:28:54.573]                 envs <- base::Sys.getenv()
[01:28:54.573]                 names <- names(envs)
[01:28:54.573]                 common <- intersect(names, old_names)
[01:28:54.573]                 added <- setdiff(names, old_names)
[01:28:54.573]                 removed <- setdiff(old_names, names)
[01:28:54.573]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:54.573]                   envs[common]]
[01:28:54.573]                 NAMES <- toupper(changed)
[01:28:54.573]                 args <- list()
[01:28:54.573]                 for (kk in seq_along(NAMES)) {
[01:28:54.573]                   name <- changed[[kk]]
[01:28:54.573]                   NAME <- NAMES[[kk]]
[01:28:54.573]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.573]                     next
[01:28:54.573]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:54.573]                 }
[01:28:54.573]                 NAMES <- toupper(added)
[01:28:54.573]                 for (kk in seq_along(NAMES)) {
[01:28:54.573]                   name <- added[[kk]]
[01:28:54.573]                   NAME <- NAMES[[kk]]
[01:28:54.573]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.573]                     next
[01:28:54.573]                   args[[name]] <- ""
[01:28:54.573]                 }
[01:28:54.573]                 NAMES <- toupper(removed)
[01:28:54.573]                 for (kk in seq_along(NAMES)) {
[01:28:54.573]                   name <- removed[[kk]]
[01:28:54.573]                   NAME <- NAMES[[kk]]
[01:28:54.573]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.573]                     next
[01:28:54.573]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:54.573]                 }
[01:28:54.573]                 if (length(args) > 0) 
[01:28:54.573]                   base::do.call(base::Sys.setenv, args = args)
[01:28:54.573]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:54.573]             }
[01:28:54.573]             else {
[01:28:54.573]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:54.573]             }
[01:28:54.573]             {
[01:28:54.573]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:54.573]                   0L) {
[01:28:54.573]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:54.573]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:54.573]                   base::options(opts)
[01:28:54.573]                 }
[01:28:54.573]                 {
[01:28:54.573]                   {
[01:28:54.573]                     NULL
[01:28:54.573]                     RNGkind("Mersenne-Twister")
[01:28:54.573]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:54.573]                       inherits = FALSE)
[01:28:54.573]                   }
[01:28:54.573]                   options(future.plan = NULL)
[01:28:54.573]                   if (is.na(NA_character_)) 
[01:28:54.573]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:54.573]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:54.573]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:54.573]                   {
[01:28:54.573]                     future <- SequentialFuture(..., envir = envir)
[01:28:54.573]                     if (!future$lazy) 
[01:28:54.573]                       future <- run(future)
[01:28:54.573]                     invisible(future)
[01:28:54.573]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:54.573]                 }
[01:28:54.573]             }
[01:28:54.573]         }
[01:28:54.573]     })
[01:28:54.573]     if (TRUE) {
[01:28:54.573]         base::sink(type = "output", split = FALSE)
[01:28:54.573]         if (TRUE) {
[01:28:54.573]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:54.573]         }
[01:28:54.573]         else {
[01:28:54.573]             ...future.result["stdout"] <- base::list(NULL)
[01:28:54.573]         }
[01:28:54.573]         base::close(...future.stdout)
[01:28:54.573]         ...future.stdout <- NULL
[01:28:54.573]     }
[01:28:54.573]     ...future.result$conditions <- ...future.conditions
[01:28:54.573]     ...future.result$finished <- base::Sys.time()
[01:28:54.573]     ...future.result
[01:28:54.573] }
[01:28:54.577] plan(): Setting new future strategy stack:
[01:28:54.577] List of future strategies:
[01:28:54.577] 1. sequential:
[01:28:54.577]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:54.577]    - tweaked: FALSE
[01:28:54.577]    - call: NULL
[01:28:54.578] plan(): nbrOfWorkers() = 1
[01:28:54.579] plan(): Setting new future strategy stack:
[01:28:54.579] List of future strategies:
[01:28:54.579] 1. sequential:
[01:28:54.579]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:54.579]    - tweaked: FALSE
[01:28:54.579]    - call: plan(strategy)
[01:28:54.580] plan(): nbrOfWorkers() = 1
[01:28:54.580] SequentialFuture started (and completed)
[01:28:54.580] - Launch lazy future ... done
[01:28:54.581] run() for 'SequentialFuture' ... done
[01:28:54.581] getGlobalsAndPackages() ...
[01:28:54.581] Searching for globals...
[01:28:54.582] - globals found: [1] '{'
[01:28:54.582] Searching for globals ... DONE
[01:28:54.582] Resolving globals: FALSE
[01:28:54.583] 
[01:28:54.583] 
[01:28:54.583] getGlobalsAndPackages() ... DONE
[01:28:54.583] run() for 'Future' ...
[01:28:54.583] - state: 'created'
[01:28:54.584] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:54.584] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:54.584] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:54.584]   - Field: 'label'
[01:28:54.585]   - Field: 'local'
[01:28:54.585]   - Field: 'owner'
[01:28:54.585]   - Field: 'envir'
[01:28:54.585]   - Field: 'packages'
[01:28:54.585]   - Field: 'gc'
[01:28:54.585]   - Field: 'conditions'
[01:28:54.586]   - Field: 'expr'
[01:28:54.586]   - Field: 'uuid'
[01:28:54.586]   - Field: 'seed'
[01:28:54.586]   - Field: 'version'
[01:28:54.586]   - Field: 'result'
[01:28:54.586]   - Field: 'asynchronous'
[01:28:54.587]   - Field: 'calls'
[01:28:54.587]   - Field: 'globals'
[01:28:54.587]   - Field: 'stdout'
[01:28:54.587]   - Field: 'earlySignal'
[01:28:54.587]   - Field: 'lazy'
[01:28:54.587]   - Field: 'state'
[01:28:54.588] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:54.588] - Launch lazy future ...
[01:28:54.588] Packages needed by the future expression (n = 0): <none>
[01:28:54.588] Packages needed by future strategies (n = 0): <none>
[01:28:54.589] {
[01:28:54.589]     {
[01:28:54.589]         {
[01:28:54.589]             ...future.startTime <- base::Sys.time()
[01:28:54.589]             {
[01:28:54.589]                 {
[01:28:54.589]                   {
[01:28:54.589]                     base::local({
[01:28:54.589]                       has_future <- base::requireNamespace("future", 
[01:28:54.589]                         quietly = TRUE)
[01:28:54.589]                       if (has_future) {
[01:28:54.589]                         ns <- base::getNamespace("future")
[01:28:54.589]                         version <- ns[[".package"]][["version"]]
[01:28:54.589]                         if (is.null(version)) 
[01:28:54.589]                           version <- utils::packageVersion("future")
[01:28:54.589]                       }
[01:28:54.589]                       else {
[01:28:54.589]                         version <- NULL
[01:28:54.589]                       }
[01:28:54.589]                       if (!has_future || version < "1.8.0") {
[01:28:54.589]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:54.589]                           "", base::R.version$version.string), 
[01:28:54.589]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:54.589]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:54.589]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:54.589]                             "release", "version")], collapse = " "), 
[01:28:54.589]                           hostname = base::Sys.info()[["nodename"]])
[01:28:54.589]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:54.589]                           info)
[01:28:54.589]                         info <- base::paste(info, collapse = "; ")
[01:28:54.589]                         if (!has_future) {
[01:28:54.589]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:54.589]                             info)
[01:28:54.589]                         }
[01:28:54.589]                         else {
[01:28:54.589]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:54.589]                             info, version)
[01:28:54.589]                         }
[01:28:54.589]                         base::stop(msg)
[01:28:54.589]                       }
[01:28:54.589]                     })
[01:28:54.589]                   }
[01:28:54.589]                   options(future.plan = NULL)
[01:28:54.589]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:54.589]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:54.589]                 }
[01:28:54.589]                 ...future.workdir <- getwd()
[01:28:54.589]             }
[01:28:54.589]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:54.589]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:54.589]         }
[01:28:54.589]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:54.589]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:54.589]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:54.589]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:54.589]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:54.589]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:54.589]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:54.589]             base::names(...future.oldOptions))
[01:28:54.589]     }
[01:28:54.589]     if (FALSE) {
[01:28:54.589]     }
[01:28:54.589]     else {
[01:28:54.589]         if (TRUE) {
[01:28:54.589]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:54.589]                 open = "w")
[01:28:54.589]         }
[01:28:54.589]         else {
[01:28:54.589]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:54.589]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:54.589]         }
[01:28:54.589]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:54.589]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:54.589]             base::sink(type = "output", split = FALSE)
[01:28:54.589]             base::close(...future.stdout)
[01:28:54.589]         }, add = TRUE)
[01:28:54.589]     }
[01:28:54.589]     ...future.frame <- base::sys.nframe()
[01:28:54.589]     ...future.conditions <- base::list()
[01:28:54.589]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:54.589]     if (FALSE) {
[01:28:54.589]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:54.589]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:54.589]     }
[01:28:54.589]     ...future.result <- base::tryCatch({
[01:28:54.589]         base::withCallingHandlers({
[01:28:54.589]             ...future.value <- base::withVisible(base::local({
[01:28:54.589]                 2
[01:28:54.589]             }))
[01:28:54.589]             future::FutureResult(value = ...future.value$value, 
[01:28:54.589]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:54.589]                   ...future.rng), globalenv = if (FALSE) 
[01:28:54.589]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:54.589]                     ...future.globalenv.names))
[01:28:54.589]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:54.589]         }, condition = base::local({
[01:28:54.589]             c <- base::c
[01:28:54.589]             inherits <- base::inherits
[01:28:54.589]             invokeRestart <- base::invokeRestart
[01:28:54.589]             length <- base::length
[01:28:54.589]             list <- base::list
[01:28:54.589]             seq.int <- base::seq.int
[01:28:54.589]             signalCondition <- base::signalCondition
[01:28:54.589]             sys.calls <- base::sys.calls
[01:28:54.589]             `[[` <- base::`[[`
[01:28:54.589]             `+` <- base::`+`
[01:28:54.589]             `<<-` <- base::`<<-`
[01:28:54.589]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:54.589]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:54.589]                   3L)]
[01:28:54.589]             }
[01:28:54.589]             function(cond) {
[01:28:54.589]                 is_error <- inherits(cond, "error")
[01:28:54.589]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:54.589]                   NULL)
[01:28:54.589]                 if (is_error) {
[01:28:54.589]                   sessionInformation <- function() {
[01:28:54.589]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:54.589]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:54.589]                       search = base::search(), system = base::Sys.info())
[01:28:54.589]                   }
[01:28:54.589]                   ...future.conditions[[length(...future.conditions) + 
[01:28:54.589]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:54.589]                     cond$call), session = sessionInformation(), 
[01:28:54.589]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:54.589]                   signalCondition(cond)
[01:28:54.589]                 }
[01:28:54.589]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:54.589]                 "immediateCondition"))) {
[01:28:54.589]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:54.589]                   ...future.conditions[[length(...future.conditions) + 
[01:28:54.589]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:54.589]                   if (TRUE && !signal) {
[01:28:54.589]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:54.589]                     {
[01:28:54.589]                       inherits <- base::inherits
[01:28:54.589]                       invokeRestart <- base::invokeRestart
[01:28:54.589]                       is.null <- base::is.null
[01:28:54.589]                       muffled <- FALSE
[01:28:54.589]                       if (inherits(cond, "message")) {
[01:28:54.589]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:54.589]                         if (muffled) 
[01:28:54.589]                           invokeRestart("muffleMessage")
[01:28:54.589]                       }
[01:28:54.589]                       else if (inherits(cond, "warning")) {
[01:28:54.589]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:54.589]                         if (muffled) 
[01:28:54.589]                           invokeRestart("muffleWarning")
[01:28:54.589]                       }
[01:28:54.589]                       else if (inherits(cond, "condition")) {
[01:28:54.589]                         if (!is.null(pattern)) {
[01:28:54.589]                           computeRestarts <- base::computeRestarts
[01:28:54.589]                           grepl <- base::grepl
[01:28:54.589]                           restarts <- computeRestarts(cond)
[01:28:54.589]                           for (restart in restarts) {
[01:28:54.589]                             name <- restart$name
[01:28:54.589]                             if (is.null(name)) 
[01:28:54.589]                               next
[01:28:54.589]                             if (!grepl(pattern, name)) 
[01:28:54.589]                               next
[01:28:54.589]                             invokeRestart(restart)
[01:28:54.589]                             muffled <- TRUE
[01:28:54.589]                             break
[01:28:54.589]                           }
[01:28:54.589]                         }
[01:28:54.589]                       }
[01:28:54.589]                       invisible(muffled)
[01:28:54.589]                     }
[01:28:54.589]                     muffleCondition(cond, pattern = "^muffle")
[01:28:54.589]                   }
[01:28:54.589]                 }
[01:28:54.589]                 else {
[01:28:54.589]                   if (TRUE) {
[01:28:54.589]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:54.589]                     {
[01:28:54.589]                       inherits <- base::inherits
[01:28:54.589]                       invokeRestart <- base::invokeRestart
[01:28:54.589]                       is.null <- base::is.null
[01:28:54.589]                       muffled <- FALSE
[01:28:54.589]                       if (inherits(cond, "message")) {
[01:28:54.589]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:54.589]                         if (muffled) 
[01:28:54.589]                           invokeRestart("muffleMessage")
[01:28:54.589]                       }
[01:28:54.589]                       else if (inherits(cond, "warning")) {
[01:28:54.589]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:54.589]                         if (muffled) 
[01:28:54.589]                           invokeRestart("muffleWarning")
[01:28:54.589]                       }
[01:28:54.589]                       else if (inherits(cond, "condition")) {
[01:28:54.589]                         if (!is.null(pattern)) {
[01:28:54.589]                           computeRestarts <- base::computeRestarts
[01:28:54.589]                           grepl <- base::grepl
[01:28:54.589]                           restarts <- computeRestarts(cond)
[01:28:54.589]                           for (restart in restarts) {
[01:28:54.589]                             name <- restart$name
[01:28:54.589]                             if (is.null(name)) 
[01:28:54.589]                               next
[01:28:54.589]                             if (!grepl(pattern, name)) 
[01:28:54.589]                               next
[01:28:54.589]                             invokeRestart(restart)
[01:28:54.589]                             muffled <- TRUE
[01:28:54.589]                             break
[01:28:54.589]                           }
[01:28:54.589]                         }
[01:28:54.589]                       }
[01:28:54.589]                       invisible(muffled)
[01:28:54.589]                     }
[01:28:54.589]                     muffleCondition(cond, pattern = "^muffle")
[01:28:54.589]                   }
[01:28:54.589]                 }
[01:28:54.589]             }
[01:28:54.589]         }))
[01:28:54.589]     }, error = function(ex) {
[01:28:54.589]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:54.589]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:54.589]                 ...future.rng), started = ...future.startTime, 
[01:28:54.589]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:54.589]             version = "1.8"), class = "FutureResult")
[01:28:54.589]     }, finally = {
[01:28:54.589]         if (!identical(...future.workdir, getwd())) 
[01:28:54.589]             setwd(...future.workdir)
[01:28:54.589]         {
[01:28:54.589]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:54.589]                 ...future.oldOptions$nwarnings <- NULL
[01:28:54.589]             }
[01:28:54.589]             base::options(...future.oldOptions)
[01:28:54.589]             if (.Platform$OS.type == "windows") {
[01:28:54.589]                 old_names <- names(...future.oldEnvVars)
[01:28:54.589]                 envs <- base::Sys.getenv()
[01:28:54.589]                 names <- names(envs)
[01:28:54.589]                 common <- intersect(names, old_names)
[01:28:54.589]                 added <- setdiff(names, old_names)
[01:28:54.589]                 removed <- setdiff(old_names, names)
[01:28:54.589]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:54.589]                   envs[common]]
[01:28:54.589]                 NAMES <- toupper(changed)
[01:28:54.589]                 args <- list()
[01:28:54.589]                 for (kk in seq_along(NAMES)) {
[01:28:54.589]                   name <- changed[[kk]]
[01:28:54.589]                   NAME <- NAMES[[kk]]
[01:28:54.589]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.589]                     next
[01:28:54.589]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:54.589]                 }
[01:28:54.589]                 NAMES <- toupper(added)
[01:28:54.589]                 for (kk in seq_along(NAMES)) {
[01:28:54.589]                   name <- added[[kk]]
[01:28:54.589]                   NAME <- NAMES[[kk]]
[01:28:54.589]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.589]                     next
[01:28:54.589]                   args[[name]] <- ""
[01:28:54.589]                 }
[01:28:54.589]                 NAMES <- toupper(removed)
[01:28:54.589]                 for (kk in seq_along(NAMES)) {
[01:28:54.589]                   name <- removed[[kk]]
[01:28:54.589]                   NAME <- NAMES[[kk]]
[01:28:54.589]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.589]                     next
[01:28:54.589]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:54.589]                 }
[01:28:54.589]                 if (length(args) > 0) 
[01:28:54.589]                   base::do.call(base::Sys.setenv, args = args)
[01:28:54.589]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:54.589]             }
[01:28:54.589]             else {
[01:28:54.589]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:54.589]             }
[01:28:54.589]             {
[01:28:54.589]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:54.589]                   0L) {
[01:28:54.589]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:54.589]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:54.589]                   base::options(opts)
[01:28:54.589]                 }
[01:28:54.589]                 {
[01:28:54.589]                   {
[01:28:54.589]                     NULL
[01:28:54.589]                     RNGkind("Mersenne-Twister")
[01:28:54.589]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:54.589]                       inherits = FALSE)
[01:28:54.589]                   }
[01:28:54.589]                   options(future.plan = NULL)
[01:28:54.589]                   if (is.na(NA_character_)) 
[01:28:54.589]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:54.589]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:54.589]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:54.589]                   {
[01:28:54.589]                     future <- SequentialFuture(..., envir = envir)
[01:28:54.589]                     if (!future$lazy) 
[01:28:54.589]                       future <- run(future)
[01:28:54.589]                     invisible(future)
[01:28:54.589]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:54.589]                 }
[01:28:54.589]             }
[01:28:54.589]         }
[01:28:54.589]     })
[01:28:54.589]     if (TRUE) {
[01:28:54.589]         base::sink(type = "output", split = FALSE)
[01:28:54.589]         if (TRUE) {
[01:28:54.589]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:54.589]         }
[01:28:54.589]         else {
[01:28:54.589]             ...future.result["stdout"] <- base::list(NULL)
[01:28:54.589]         }
[01:28:54.589]         base::close(...future.stdout)
[01:28:54.589]         ...future.stdout <- NULL
[01:28:54.589]     }
[01:28:54.589]     ...future.result$conditions <- ...future.conditions
[01:28:54.589]     ...future.result$finished <- base::Sys.time()
[01:28:54.589]     ...future.result
[01:28:54.589] }
[01:28:54.593] plan(): Setting new future strategy stack:
[01:28:54.593] List of future strategies:
[01:28:54.593] 1. sequential:
[01:28:54.593]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:54.593]    - tweaked: FALSE
[01:28:54.593]    - call: NULL
[01:28:54.593] plan(): nbrOfWorkers() = 1
[01:28:54.595] plan(): Setting new future strategy stack:
[01:28:54.595] List of future strategies:
[01:28:54.595] 1. sequential:
[01:28:54.595]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:54.595]    - tweaked: FALSE
[01:28:54.595]    - call: plan(strategy)
[01:28:54.595] plan(): nbrOfWorkers() = 1
[01:28:54.596] SequentialFuture started (and completed)
[01:28:54.596] - Launch lazy future ... done
[01:28:54.596] run() for 'SequentialFuture' ... done
[01:28:54.597] resolve() on list environment ...
[01:28:54.597]  recursive: 0
[01:28:54.597]  length: 3
[01:28:54.598]  elements: 'a', 'b', 'c'
[01:28:54.598] resolved() for 'SequentialFuture' ...
[01:28:54.598] - state: 'finished'
[01:28:54.598] - run: TRUE
[01:28:54.598] - result: 'FutureResult'
[01:28:54.599] resolved() for 'SequentialFuture' ... done
[01:28:54.599] Future #1
[01:28:54.599]  length: 2 (resolved future 1)
[01:28:54.599] resolved() for 'SequentialFuture' ...
[01:28:54.599] - state: 'finished'
[01:28:54.599] - run: TRUE
[01:28:54.600] - result: 'FutureResult'
[01:28:54.600] resolved() for 'SequentialFuture' ... done
[01:28:54.600] Future #2
[01:28:54.600]  length: 1 (resolved future 2)
[01:28:54.600]  length: 0 (resolved future 3)
[01:28:54.601] resolve() on list environment ... DONE
[01:28:54.601] getGlobalsAndPackages() ...
[01:28:54.601] Searching for globals...
[01:28:54.603] - globals found: [1] '{'
[01:28:54.603] Searching for globals ... DONE
[01:28:54.603] Resolving globals: FALSE
[01:28:54.604] 
[01:28:54.604] 
[01:28:54.604] getGlobalsAndPackages() ... DONE
[01:28:54.604] run() for 'Future' ...
[01:28:54.604] - state: 'created'
[01:28:54.605] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:54.605] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:54.605] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:54.605]   - Field: 'label'
[01:28:54.606]   - Field: 'local'
[01:28:54.606]   - Field: 'owner'
[01:28:54.606]   - Field: 'envir'
[01:28:54.606]   - Field: 'packages'
[01:28:54.606]   - Field: 'gc'
[01:28:54.606]   - Field: 'conditions'
[01:28:54.607]   - Field: 'expr'
[01:28:54.607]   - Field: 'uuid'
[01:28:54.607]   - Field: 'seed'
[01:28:54.607]   - Field: 'version'
[01:28:54.607]   - Field: 'result'
[01:28:54.607]   - Field: 'asynchronous'
[01:28:54.608]   - Field: 'calls'
[01:28:54.608]   - Field: 'globals'
[01:28:54.608]   - Field: 'stdout'
[01:28:54.608]   - Field: 'earlySignal'
[01:28:54.608]   - Field: 'lazy'
[01:28:54.609]   - Field: 'state'
[01:28:54.609] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:54.609] - Launch lazy future ...
[01:28:54.609] Packages needed by the future expression (n = 0): <none>
[01:28:54.609] Packages needed by future strategies (n = 0): <none>
[01:28:54.610] {
[01:28:54.610]     {
[01:28:54.610]         {
[01:28:54.610]             ...future.startTime <- base::Sys.time()
[01:28:54.610]             {
[01:28:54.610]                 {
[01:28:54.610]                   {
[01:28:54.610]                     base::local({
[01:28:54.610]                       has_future <- base::requireNamespace("future", 
[01:28:54.610]                         quietly = TRUE)
[01:28:54.610]                       if (has_future) {
[01:28:54.610]                         ns <- base::getNamespace("future")
[01:28:54.610]                         version <- ns[[".package"]][["version"]]
[01:28:54.610]                         if (is.null(version)) 
[01:28:54.610]                           version <- utils::packageVersion("future")
[01:28:54.610]                       }
[01:28:54.610]                       else {
[01:28:54.610]                         version <- NULL
[01:28:54.610]                       }
[01:28:54.610]                       if (!has_future || version < "1.8.0") {
[01:28:54.610]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:54.610]                           "", base::R.version$version.string), 
[01:28:54.610]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:54.610]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:54.610]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:54.610]                             "release", "version")], collapse = " "), 
[01:28:54.610]                           hostname = base::Sys.info()[["nodename"]])
[01:28:54.610]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:54.610]                           info)
[01:28:54.610]                         info <- base::paste(info, collapse = "; ")
[01:28:54.610]                         if (!has_future) {
[01:28:54.610]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:54.610]                             info)
[01:28:54.610]                         }
[01:28:54.610]                         else {
[01:28:54.610]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:54.610]                             info, version)
[01:28:54.610]                         }
[01:28:54.610]                         base::stop(msg)
[01:28:54.610]                       }
[01:28:54.610]                     })
[01:28:54.610]                   }
[01:28:54.610]                   options(future.plan = NULL)
[01:28:54.610]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:54.610]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:54.610]                 }
[01:28:54.610]                 ...future.workdir <- getwd()
[01:28:54.610]             }
[01:28:54.610]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:54.610]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:54.610]         }
[01:28:54.610]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:54.610]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:54.610]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:54.610]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:54.610]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:54.610]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:54.610]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:54.610]             base::names(...future.oldOptions))
[01:28:54.610]     }
[01:28:54.610]     if (FALSE) {
[01:28:54.610]     }
[01:28:54.610]     else {
[01:28:54.610]         if (TRUE) {
[01:28:54.610]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:54.610]                 open = "w")
[01:28:54.610]         }
[01:28:54.610]         else {
[01:28:54.610]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:54.610]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:54.610]         }
[01:28:54.610]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:54.610]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:54.610]             base::sink(type = "output", split = FALSE)
[01:28:54.610]             base::close(...future.stdout)
[01:28:54.610]         }, add = TRUE)
[01:28:54.610]     }
[01:28:54.610]     ...future.frame <- base::sys.nframe()
[01:28:54.610]     ...future.conditions <- base::list()
[01:28:54.610]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:54.610]     if (FALSE) {
[01:28:54.610]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:54.610]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:54.610]     }
[01:28:54.610]     ...future.result <- base::tryCatch({
[01:28:54.610]         base::withCallingHandlers({
[01:28:54.610]             ...future.value <- base::withVisible(base::local({
[01:28:54.610]                 1
[01:28:54.610]             }))
[01:28:54.610]             future::FutureResult(value = ...future.value$value, 
[01:28:54.610]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:54.610]                   ...future.rng), globalenv = if (FALSE) 
[01:28:54.610]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:54.610]                     ...future.globalenv.names))
[01:28:54.610]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:54.610]         }, condition = base::local({
[01:28:54.610]             c <- base::c
[01:28:54.610]             inherits <- base::inherits
[01:28:54.610]             invokeRestart <- base::invokeRestart
[01:28:54.610]             length <- base::length
[01:28:54.610]             list <- base::list
[01:28:54.610]             seq.int <- base::seq.int
[01:28:54.610]             signalCondition <- base::signalCondition
[01:28:54.610]             sys.calls <- base::sys.calls
[01:28:54.610]             `[[` <- base::`[[`
[01:28:54.610]             `+` <- base::`+`
[01:28:54.610]             `<<-` <- base::`<<-`
[01:28:54.610]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:54.610]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:54.610]                   3L)]
[01:28:54.610]             }
[01:28:54.610]             function(cond) {
[01:28:54.610]                 is_error <- inherits(cond, "error")
[01:28:54.610]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:54.610]                   NULL)
[01:28:54.610]                 if (is_error) {
[01:28:54.610]                   sessionInformation <- function() {
[01:28:54.610]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:54.610]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:54.610]                       search = base::search(), system = base::Sys.info())
[01:28:54.610]                   }
[01:28:54.610]                   ...future.conditions[[length(...future.conditions) + 
[01:28:54.610]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:54.610]                     cond$call), session = sessionInformation(), 
[01:28:54.610]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:54.610]                   signalCondition(cond)
[01:28:54.610]                 }
[01:28:54.610]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:54.610]                 "immediateCondition"))) {
[01:28:54.610]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:54.610]                   ...future.conditions[[length(...future.conditions) + 
[01:28:54.610]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:54.610]                   if (TRUE && !signal) {
[01:28:54.610]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:54.610]                     {
[01:28:54.610]                       inherits <- base::inherits
[01:28:54.610]                       invokeRestart <- base::invokeRestart
[01:28:54.610]                       is.null <- base::is.null
[01:28:54.610]                       muffled <- FALSE
[01:28:54.610]                       if (inherits(cond, "message")) {
[01:28:54.610]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:54.610]                         if (muffled) 
[01:28:54.610]                           invokeRestart("muffleMessage")
[01:28:54.610]                       }
[01:28:54.610]                       else if (inherits(cond, "warning")) {
[01:28:54.610]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:54.610]                         if (muffled) 
[01:28:54.610]                           invokeRestart("muffleWarning")
[01:28:54.610]                       }
[01:28:54.610]                       else if (inherits(cond, "condition")) {
[01:28:54.610]                         if (!is.null(pattern)) {
[01:28:54.610]                           computeRestarts <- base::computeRestarts
[01:28:54.610]                           grepl <- base::grepl
[01:28:54.610]                           restarts <- computeRestarts(cond)
[01:28:54.610]                           for (restart in restarts) {
[01:28:54.610]                             name <- restart$name
[01:28:54.610]                             if (is.null(name)) 
[01:28:54.610]                               next
[01:28:54.610]                             if (!grepl(pattern, name)) 
[01:28:54.610]                               next
[01:28:54.610]                             invokeRestart(restart)
[01:28:54.610]                             muffled <- TRUE
[01:28:54.610]                             break
[01:28:54.610]                           }
[01:28:54.610]                         }
[01:28:54.610]                       }
[01:28:54.610]                       invisible(muffled)
[01:28:54.610]                     }
[01:28:54.610]                     muffleCondition(cond, pattern = "^muffle")
[01:28:54.610]                   }
[01:28:54.610]                 }
[01:28:54.610]                 else {
[01:28:54.610]                   if (TRUE) {
[01:28:54.610]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:54.610]                     {
[01:28:54.610]                       inherits <- base::inherits
[01:28:54.610]                       invokeRestart <- base::invokeRestart
[01:28:54.610]                       is.null <- base::is.null
[01:28:54.610]                       muffled <- FALSE
[01:28:54.610]                       if (inherits(cond, "message")) {
[01:28:54.610]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:54.610]                         if (muffled) 
[01:28:54.610]                           invokeRestart("muffleMessage")
[01:28:54.610]                       }
[01:28:54.610]                       else if (inherits(cond, "warning")) {
[01:28:54.610]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:54.610]                         if (muffled) 
[01:28:54.610]                           invokeRestart("muffleWarning")
[01:28:54.610]                       }
[01:28:54.610]                       else if (inherits(cond, "condition")) {
[01:28:54.610]                         if (!is.null(pattern)) {
[01:28:54.610]                           computeRestarts <- base::computeRestarts
[01:28:54.610]                           grepl <- base::grepl
[01:28:54.610]                           restarts <- computeRestarts(cond)
[01:28:54.610]                           for (restart in restarts) {
[01:28:54.610]                             name <- restart$name
[01:28:54.610]                             if (is.null(name)) 
[01:28:54.610]                               next
[01:28:54.610]                             if (!grepl(pattern, name)) 
[01:28:54.610]                               next
[01:28:54.610]                             invokeRestart(restart)
[01:28:54.610]                             muffled <- TRUE
[01:28:54.610]                             break
[01:28:54.610]                           }
[01:28:54.610]                         }
[01:28:54.610]                       }
[01:28:54.610]                       invisible(muffled)
[01:28:54.610]                     }
[01:28:54.610]                     muffleCondition(cond, pattern = "^muffle")
[01:28:54.610]                   }
[01:28:54.610]                 }
[01:28:54.610]             }
[01:28:54.610]         }))
[01:28:54.610]     }, error = function(ex) {
[01:28:54.610]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:54.610]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:54.610]                 ...future.rng), started = ...future.startTime, 
[01:28:54.610]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:54.610]             version = "1.8"), class = "FutureResult")
[01:28:54.610]     }, finally = {
[01:28:54.610]         if (!identical(...future.workdir, getwd())) 
[01:28:54.610]             setwd(...future.workdir)
[01:28:54.610]         {
[01:28:54.610]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:54.610]                 ...future.oldOptions$nwarnings <- NULL
[01:28:54.610]             }
[01:28:54.610]             base::options(...future.oldOptions)
[01:28:54.610]             if (.Platform$OS.type == "windows") {
[01:28:54.610]                 old_names <- names(...future.oldEnvVars)
[01:28:54.610]                 envs <- base::Sys.getenv()
[01:28:54.610]                 names <- names(envs)
[01:28:54.610]                 common <- intersect(names, old_names)
[01:28:54.610]                 added <- setdiff(names, old_names)
[01:28:54.610]                 removed <- setdiff(old_names, names)
[01:28:54.610]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:54.610]                   envs[common]]
[01:28:54.610]                 NAMES <- toupper(changed)
[01:28:54.610]                 args <- list()
[01:28:54.610]                 for (kk in seq_along(NAMES)) {
[01:28:54.610]                   name <- changed[[kk]]
[01:28:54.610]                   NAME <- NAMES[[kk]]
[01:28:54.610]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.610]                     next
[01:28:54.610]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:54.610]                 }
[01:28:54.610]                 NAMES <- toupper(added)
[01:28:54.610]                 for (kk in seq_along(NAMES)) {
[01:28:54.610]                   name <- added[[kk]]
[01:28:54.610]                   NAME <- NAMES[[kk]]
[01:28:54.610]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.610]                     next
[01:28:54.610]                   args[[name]] <- ""
[01:28:54.610]                 }
[01:28:54.610]                 NAMES <- toupper(removed)
[01:28:54.610]                 for (kk in seq_along(NAMES)) {
[01:28:54.610]                   name <- removed[[kk]]
[01:28:54.610]                   NAME <- NAMES[[kk]]
[01:28:54.610]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.610]                     next
[01:28:54.610]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:54.610]                 }
[01:28:54.610]                 if (length(args) > 0) 
[01:28:54.610]                   base::do.call(base::Sys.setenv, args = args)
[01:28:54.610]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:54.610]             }
[01:28:54.610]             else {
[01:28:54.610]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:54.610]             }
[01:28:54.610]             {
[01:28:54.610]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:54.610]                   0L) {
[01:28:54.610]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:54.610]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:54.610]                   base::options(opts)
[01:28:54.610]                 }
[01:28:54.610]                 {
[01:28:54.610]                   {
[01:28:54.610]                     NULL
[01:28:54.610]                     RNGkind("Mersenne-Twister")
[01:28:54.610]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:54.610]                       inherits = FALSE)
[01:28:54.610]                   }
[01:28:54.610]                   options(future.plan = NULL)
[01:28:54.610]                   if (is.na(NA_character_)) 
[01:28:54.610]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:54.610]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:54.610]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:54.610]                   {
[01:28:54.610]                     future <- SequentialFuture(..., envir = envir)
[01:28:54.610]                     if (!future$lazy) 
[01:28:54.610]                       future <- run(future)
[01:28:54.610]                     invisible(future)
[01:28:54.610]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:54.610]                 }
[01:28:54.610]             }
[01:28:54.610]         }
[01:28:54.610]     })
[01:28:54.610]     if (TRUE) {
[01:28:54.610]         base::sink(type = "output", split = FALSE)
[01:28:54.610]         if (TRUE) {
[01:28:54.610]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:54.610]         }
[01:28:54.610]         else {
[01:28:54.610]             ...future.result["stdout"] <- base::list(NULL)
[01:28:54.610]         }
[01:28:54.610]         base::close(...future.stdout)
[01:28:54.610]         ...future.stdout <- NULL
[01:28:54.610]     }
[01:28:54.610]     ...future.result$conditions <- ...future.conditions
[01:28:54.610]     ...future.result$finished <- base::Sys.time()
[01:28:54.610]     ...future.result
[01:28:54.610] }
[01:28:54.614] plan(): Setting new future strategy stack:
[01:28:54.614] List of future strategies:
[01:28:54.614] 1. sequential:
[01:28:54.614]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:54.614]    - tweaked: FALSE
[01:28:54.614]    - call: NULL
[01:28:54.615] plan(): nbrOfWorkers() = 1
[01:28:54.616] plan(): Setting new future strategy stack:
[01:28:54.616] List of future strategies:
[01:28:54.616] 1. sequential:
[01:28:54.616]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:54.616]    - tweaked: FALSE
[01:28:54.616]    - call: plan(strategy)
[01:28:54.616] plan(): nbrOfWorkers() = 1
[01:28:54.617] SequentialFuture started (and completed)
[01:28:54.617] - Launch lazy future ... done
[01:28:54.617] run() for 'SequentialFuture' ... done
[01:28:54.617] getGlobalsAndPackages() ...
[01:28:54.618] Searching for globals...
[01:28:54.619] - globals found: [2] '{', 'Sys.sleep'
[01:28:54.619] Searching for globals ... DONE
[01:28:54.619] Resolving globals: FALSE
[01:28:54.620] 
[01:28:54.620] 
[01:28:54.620] getGlobalsAndPackages() ... DONE
[01:28:54.620] run() for 'Future' ...
[01:28:54.620] - state: 'created'
[01:28:54.621] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:54.621] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:54.621] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:54.621]   - Field: 'label'
[01:28:54.621]   - Field: 'local'
[01:28:54.622]   - Field: 'owner'
[01:28:54.622]   - Field: 'envir'
[01:28:54.622]   - Field: 'packages'
[01:28:54.622]   - Field: 'gc'
[01:28:54.622]   - Field: 'conditions'
[01:28:54.623]   - Field: 'expr'
[01:28:54.623]   - Field: 'uuid'
[01:28:54.623]   - Field: 'seed'
[01:28:54.623]   - Field: 'version'
[01:28:54.623]   - Field: 'result'
[01:28:54.623]   - Field: 'asynchronous'
[01:28:54.624]   - Field: 'calls'
[01:28:54.624]   - Field: 'globals'
[01:28:54.624]   - Field: 'stdout'
[01:28:54.624]   - Field: 'earlySignal'
[01:28:54.624]   - Field: 'lazy'
[01:28:54.625]   - Field: 'state'
[01:28:54.625] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:54.625] - Launch lazy future ...
[01:28:54.625] Packages needed by the future expression (n = 0): <none>
[01:28:54.625] Packages needed by future strategies (n = 0): <none>
[01:28:54.626] {
[01:28:54.626]     {
[01:28:54.626]         {
[01:28:54.626]             ...future.startTime <- base::Sys.time()
[01:28:54.626]             {
[01:28:54.626]                 {
[01:28:54.626]                   {
[01:28:54.626]                     base::local({
[01:28:54.626]                       has_future <- base::requireNamespace("future", 
[01:28:54.626]                         quietly = TRUE)
[01:28:54.626]                       if (has_future) {
[01:28:54.626]                         ns <- base::getNamespace("future")
[01:28:54.626]                         version <- ns[[".package"]][["version"]]
[01:28:54.626]                         if (is.null(version)) 
[01:28:54.626]                           version <- utils::packageVersion("future")
[01:28:54.626]                       }
[01:28:54.626]                       else {
[01:28:54.626]                         version <- NULL
[01:28:54.626]                       }
[01:28:54.626]                       if (!has_future || version < "1.8.0") {
[01:28:54.626]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:54.626]                           "", base::R.version$version.string), 
[01:28:54.626]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:54.626]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:54.626]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:54.626]                             "release", "version")], collapse = " "), 
[01:28:54.626]                           hostname = base::Sys.info()[["nodename"]])
[01:28:54.626]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:54.626]                           info)
[01:28:54.626]                         info <- base::paste(info, collapse = "; ")
[01:28:54.626]                         if (!has_future) {
[01:28:54.626]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:54.626]                             info)
[01:28:54.626]                         }
[01:28:54.626]                         else {
[01:28:54.626]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:54.626]                             info, version)
[01:28:54.626]                         }
[01:28:54.626]                         base::stop(msg)
[01:28:54.626]                       }
[01:28:54.626]                     })
[01:28:54.626]                   }
[01:28:54.626]                   options(future.plan = NULL)
[01:28:54.626]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:54.626]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:54.626]                 }
[01:28:54.626]                 ...future.workdir <- getwd()
[01:28:54.626]             }
[01:28:54.626]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:54.626]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:54.626]         }
[01:28:54.626]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:54.626]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:54.626]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:54.626]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:54.626]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:54.626]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:54.626]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:54.626]             base::names(...future.oldOptions))
[01:28:54.626]     }
[01:28:54.626]     if (FALSE) {
[01:28:54.626]     }
[01:28:54.626]     else {
[01:28:54.626]         if (TRUE) {
[01:28:54.626]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:54.626]                 open = "w")
[01:28:54.626]         }
[01:28:54.626]         else {
[01:28:54.626]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:54.626]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:54.626]         }
[01:28:54.626]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:54.626]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:54.626]             base::sink(type = "output", split = FALSE)
[01:28:54.626]             base::close(...future.stdout)
[01:28:54.626]         }, add = TRUE)
[01:28:54.626]     }
[01:28:54.626]     ...future.frame <- base::sys.nframe()
[01:28:54.626]     ...future.conditions <- base::list()
[01:28:54.626]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:54.626]     if (FALSE) {
[01:28:54.626]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:54.626]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:54.626]     }
[01:28:54.626]     ...future.result <- base::tryCatch({
[01:28:54.626]         base::withCallingHandlers({
[01:28:54.626]             ...future.value <- base::withVisible(base::local({
[01:28:54.626]                 Sys.sleep(0.5)
[01:28:54.626]                 2
[01:28:54.626]             }))
[01:28:54.626]             future::FutureResult(value = ...future.value$value, 
[01:28:54.626]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:54.626]                   ...future.rng), globalenv = if (FALSE) 
[01:28:54.626]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:54.626]                     ...future.globalenv.names))
[01:28:54.626]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:54.626]         }, condition = base::local({
[01:28:54.626]             c <- base::c
[01:28:54.626]             inherits <- base::inherits
[01:28:54.626]             invokeRestart <- base::invokeRestart
[01:28:54.626]             length <- base::length
[01:28:54.626]             list <- base::list
[01:28:54.626]             seq.int <- base::seq.int
[01:28:54.626]             signalCondition <- base::signalCondition
[01:28:54.626]             sys.calls <- base::sys.calls
[01:28:54.626]             `[[` <- base::`[[`
[01:28:54.626]             `+` <- base::`+`
[01:28:54.626]             `<<-` <- base::`<<-`
[01:28:54.626]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:54.626]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:54.626]                   3L)]
[01:28:54.626]             }
[01:28:54.626]             function(cond) {
[01:28:54.626]                 is_error <- inherits(cond, "error")
[01:28:54.626]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:54.626]                   NULL)
[01:28:54.626]                 if (is_error) {
[01:28:54.626]                   sessionInformation <- function() {
[01:28:54.626]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:54.626]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:54.626]                       search = base::search(), system = base::Sys.info())
[01:28:54.626]                   }
[01:28:54.626]                   ...future.conditions[[length(...future.conditions) + 
[01:28:54.626]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:54.626]                     cond$call), session = sessionInformation(), 
[01:28:54.626]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:54.626]                   signalCondition(cond)
[01:28:54.626]                 }
[01:28:54.626]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:54.626]                 "immediateCondition"))) {
[01:28:54.626]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:54.626]                   ...future.conditions[[length(...future.conditions) + 
[01:28:54.626]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:54.626]                   if (TRUE && !signal) {
[01:28:54.626]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:54.626]                     {
[01:28:54.626]                       inherits <- base::inherits
[01:28:54.626]                       invokeRestart <- base::invokeRestart
[01:28:54.626]                       is.null <- base::is.null
[01:28:54.626]                       muffled <- FALSE
[01:28:54.626]                       if (inherits(cond, "message")) {
[01:28:54.626]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:54.626]                         if (muffled) 
[01:28:54.626]                           invokeRestart("muffleMessage")
[01:28:54.626]                       }
[01:28:54.626]                       else if (inherits(cond, "warning")) {
[01:28:54.626]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:54.626]                         if (muffled) 
[01:28:54.626]                           invokeRestart("muffleWarning")
[01:28:54.626]                       }
[01:28:54.626]                       else if (inherits(cond, "condition")) {
[01:28:54.626]                         if (!is.null(pattern)) {
[01:28:54.626]                           computeRestarts <- base::computeRestarts
[01:28:54.626]                           grepl <- base::grepl
[01:28:54.626]                           restarts <- computeRestarts(cond)
[01:28:54.626]                           for (restart in restarts) {
[01:28:54.626]                             name <- restart$name
[01:28:54.626]                             if (is.null(name)) 
[01:28:54.626]                               next
[01:28:54.626]                             if (!grepl(pattern, name)) 
[01:28:54.626]                               next
[01:28:54.626]                             invokeRestart(restart)
[01:28:54.626]                             muffled <- TRUE
[01:28:54.626]                             break
[01:28:54.626]                           }
[01:28:54.626]                         }
[01:28:54.626]                       }
[01:28:54.626]                       invisible(muffled)
[01:28:54.626]                     }
[01:28:54.626]                     muffleCondition(cond, pattern = "^muffle")
[01:28:54.626]                   }
[01:28:54.626]                 }
[01:28:54.626]                 else {
[01:28:54.626]                   if (TRUE) {
[01:28:54.626]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:54.626]                     {
[01:28:54.626]                       inherits <- base::inherits
[01:28:54.626]                       invokeRestart <- base::invokeRestart
[01:28:54.626]                       is.null <- base::is.null
[01:28:54.626]                       muffled <- FALSE
[01:28:54.626]                       if (inherits(cond, "message")) {
[01:28:54.626]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:54.626]                         if (muffled) 
[01:28:54.626]                           invokeRestart("muffleMessage")
[01:28:54.626]                       }
[01:28:54.626]                       else if (inherits(cond, "warning")) {
[01:28:54.626]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:54.626]                         if (muffled) 
[01:28:54.626]                           invokeRestart("muffleWarning")
[01:28:54.626]                       }
[01:28:54.626]                       else if (inherits(cond, "condition")) {
[01:28:54.626]                         if (!is.null(pattern)) {
[01:28:54.626]                           computeRestarts <- base::computeRestarts
[01:28:54.626]                           grepl <- base::grepl
[01:28:54.626]                           restarts <- computeRestarts(cond)
[01:28:54.626]                           for (restart in restarts) {
[01:28:54.626]                             name <- restart$name
[01:28:54.626]                             if (is.null(name)) 
[01:28:54.626]                               next
[01:28:54.626]                             if (!grepl(pattern, name)) 
[01:28:54.626]                               next
[01:28:54.626]                             invokeRestart(restart)
[01:28:54.626]                             muffled <- TRUE
[01:28:54.626]                             break
[01:28:54.626]                           }
[01:28:54.626]                         }
[01:28:54.626]                       }
[01:28:54.626]                       invisible(muffled)
[01:28:54.626]                     }
[01:28:54.626]                     muffleCondition(cond, pattern = "^muffle")
[01:28:54.626]                   }
[01:28:54.626]                 }
[01:28:54.626]             }
[01:28:54.626]         }))
[01:28:54.626]     }, error = function(ex) {
[01:28:54.626]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:54.626]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:54.626]                 ...future.rng), started = ...future.startTime, 
[01:28:54.626]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:54.626]             version = "1.8"), class = "FutureResult")
[01:28:54.626]     }, finally = {
[01:28:54.626]         if (!identical(...future.workdir, getwd())) 
[01:28:54.626]             setwd(...future.workdir)
[01:28:54.626]         {
[01:28:54.626]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:54.626]                 ...future.oldOptions$nwarnings <- NULL
[01:28:54.626]             }
[01:28:54.626]             base::options(...future.oldOptions)
[01:28:54.626]             if (.Platform$OS.type == "windows") {
[01:28:54.626]                 old_names <- names(...future.oldEnvVars)
[01:28:54.626]                 envs <- base::Sys.getenv()
[01:28:54.626]                 names <- names(envs)
[01:28:54.626]                 common <- intersect(names, old_names)
[01:28:54.626]                 added <- setdiff(names, old_names)
[01:28:54.626]                 removed <- setdiff(old_names, names)
[01:28:54.626]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:54.626]                   envs[common]]
[01:28:54.626]                 NAMES <- toupper(changed)
[01:28:54.626]                 args <- list()
[01:28:54.626]                 for (kk in seq_along(NAMES)) {
[01:28:54.626]                   name <- changed[[kk]]
[01:28:54.626]                   NAME <- NAMES[[kk]]
[01:28:54.626]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.626]                     next
[01:28:54.626]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:54.626]                 }
[01:28:54.626]                 NAMES <- toupper(added)
[01:28:54.626]                 for (kk in seq_along(NAMES)) {
[01:28:54.626]                   name <- added[[kk]]
[01:28:54.626]                   NAME <- NAMES[[kk]]
[01:28:54.626]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.626]                     next
[01:28:54.626]                   args[[name]] <- ""
[01:28:54.626]                 }
[01:28:54.626]                 NAMES <- toupper(removed)
[01:28:54.626]                 for (kk in seq_along(NAMES)) {
[01:28:54.626]                   name <- removed[[kk]]
[01:28:54.626]                   NAME <- NAMES[[kk]]
[01:28:54.626]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:54.626]                     next
[01:28:54.626]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:54.626]                 }
[01:28:54.626]                 if (length(args) > 0) 
[01:28:54.626]                   base::do.call(base::Sys.setenv, args = args)
[01:28:54.626]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:54.626]             }
[01:28:54.626]             else {
[01:28:54.626]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:54.626]             }
[01:28:54.626]             {
[01:28:54.626]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:54.626]                   0L) {
[01:28:54.626]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:54.626]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:54.626]                   base::options(opts)
[01:28:54.626]                 }
[01:28:54.626]                 {
[01:28:54.626]                   {
[01:28:54.626]                     NULL
[01:28:54.626]                     RNGkind("Mersenne-Twister")
[01:28:54.626]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:54.626]                       inherits = FALSE)
[01:28:54.626]                   }
[01:28:54.626]                   options(future.plan = NULL)
[01:28:54.626]                   if (is.na(NA_character_)) 
[01:28:54.626]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:54.626]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:54.626]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:54.626]                   {
[01:28:54.626]                     future <- SequentialFuture(..., envir = envir)
[01:28:54.626]                     if (!future$lazy) 
[01:28:54.626]                       future <- run(future)
[01:28:54.626]                     invisible(future)
[01:28:54.626]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:54.626]                 }
[01:28:54.626]             }
[01:28:54.626]         }
[01:28:54.626]     })
[01:28:54.626]     if (TRUE) {
[01:28:54.626]         base::sink(type = "output", split = FALSE)
[01:28:54.626]         if (TRUE) {
[01:28:54.626]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:54.626]         }
[01:28:54.626]         else {
[01:28:54.626]             ...future.result["stdout"] <- base::list(NULL)
[01:28:54.626]         }
[01:28:54.626]         base::close(...future.stdout)
[01:28:54.626]         ...future.stdout <- NULL
[01:28:54.626]     }
[01:28:54.626]     ...future.result$conditions <- ...future.conditions
[01:28:54.626]     ...future.result$finished <- base::Sys.time()
[01:28:54.626]     ...future.result
[01:28:54.626] }
[01:28:54.630] plan(): Setting new future strategy stack:
[01:28:54.630] List of future strategies:
[01:28:54.630] 1. sequential:
[01:28:54.630]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:54.630]    - tweaked: FALSE
[01:28:54.630]    - call: NULL
[01:28:54.631] plan(): nbrOfWorkers() = 1
[01:28:55.142] plan(): Setting new future strategy stack:
[01:28:55.142] List of future strategies:
[01:28:55.142] 1. sequential:
[01:28:55.142]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:55.142]    - tweaked: FALSE
[01:28:55.142]    - call: plan(strategy)
[01:28:55.143] plan(): nbrOfWorkers() = 1
[01:28:55.144] SequentialFuture started (and completed)
[01:28:55.144] - Launch lazy future ... done
[01:28:55.144] run() for 'SequentialFuture' ... done
[01:28:55.145] getGlobalsAndPackages() ...
[01:28:55.145] Searching for globals...
[01:28:55.146] - globals found: [1] '{'
[01:28:55.147] Searching for globals ... DONE
[01:28:55.147] Resolving globals: FALSE
[01:28:55.147] 
[01:28:55.148] 
[01:28:55.148] getGlobalsAndPackages() ... DONE
[01:28:55.148] run() for 'Future' ...
[01:28:55.149] - state: 'created'
[01:28:55.149] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:55.149] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:55.149] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:55.150]   - Field: 'label'
[01:28:55.150]   - Field: 'local'
[01:28:55.150]   - Field: 'owner'
[01:28:55.150]   - Field: 'envir'
[01:28:55.151]   - Field: 'packages'
[01:28:55.151]   - Field: 'gc'
[01:28:55.151]   - Field: 'conditions'
[01:28:55.151]   - Field: 'expr'
[01:28:55.151]   - Field: 'uuid'
[01:28:55.152]   - Field: 'seed'
[01:28:55.152]   - Field: 'version'
[01:28:55.152]   - Field: 'result'
[01:28:55.152]   - Field: 'asynchronous'
[01:28:55.152]   - Field: 'calls'
[01:28:55.153]   - Field: 'globals'
[01:28:55.153]   - Field: 'stdout'
[01:28:55.153]   - Field: 'earlySignal'
[01:28:55.153]   - Field: 'lazy'
[01:28:55.159]   - Field: 'state'
[01:28:55.159] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:55.159] - Launch lazy future ...
[01:28:55.160] Packages needed by the future expression (n = 0): <none>
[01:28:55.161] Packages needed by future strategies (n = 0): <none>
[01:28:55.162] {
[01:28:55.162]     {
[01:28:55.162]         {
[01:28:55.162]             ...future.startTime <- base::Sys.time()
[01:28:55.162]             {
[01:28:55.162]                 {
[01:28:55.162]                   {
[01:28:55.162]                     base::local({
[01:28:55.162]                       has_future <- base::requireNamespace("future", 
[01:28:55.162]                         quietly = TRUE)
[01:28:55.162]                       if (has_future) {
[01:28:55.162]                         ns <- base::getNamespace("future")
[01:28:55.162]                         version <- ns[[".package"]][["version"]]
[01:28:55.162]                         if (is.null(version)) 
[01:28:55.162]                           version <- utils::packageVersion("future")
[01:28:55.162]                       }
[01:28:55.162]                       else {
[01:28:55.162]                         version <- NULL
[01:28:55.162]                       }
[01:28:55.162]                       if (!has_future || version < "1.8.0") {
[01:28:55.162]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:55.162]                           "", base::R.version$version.string), 
[01:28:55.162]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:55.162]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:55.162]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:55.162]                             "release", "version")], collapse = " "), 
[01:28:55.162]                           hostname = base::Sys.info()[["nodename"]])
[01:28:55.162]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:55.162]                           info)
[01:28:55.162]                         info <- base::paste(info, collapse = "; ")
[01:28:55.162]                         if (!has_future) {
[01:28:55.162]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:55.162]                             info)
[01:28:55.162]                         }
[01:28:55.162]                         else {
[01:28:55.162]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:55.162]                             info, version)
[01:28:55.162]                         }
[01:28:55.162]                         base::stop(msg)
[01:28:55.162]                       }
[01:28:55.162]                     })
[01:28:55.162]                   }
[01:28:55.162]                   options(future.plan = NULL)
[01:28:55.162]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:55.162]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:55.162]                 }
[01:28:55.162]                 ...future.workdir <- getwd()
[01:28:55.162]             }
[01:28:55.162]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:55.162]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:55.162]         }
[01:28:55.162]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:55.162]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:55.162]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:55.162]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:55.162]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:55.162]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:55.162]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:55.162]             base::names(...future.oldOptions))
[01:28:55.162]     }
[01:28:55.162]     if (FALSE) {
[01:28:55.162]     }
[01:28:55.162]     else {
[01:28:55.162]         if (TRUE) {
[01:28:55.162]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:55.162]                 open = "w")
[01:28:55.162]         }
[01:28:55.162]         else {
[01:28:55.162]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:55.162]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:55.162]         }
[01:28:55.162]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:55.162]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:55.162]             base::sink(type = "output", split = FALSE)
[01:28:55.162]             base::close(...future.stdout)
[01:28:55.162]         }, add = TRUE)
[01:28:55.162]     }
[01:28:55.162]     ...future.frame <- base::sys.nframe()
[01:28:55.162]     ...future.conditions <- base::list()
[01:28:55.162]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:55.162]     if (FALSE) {
[01:28:55.162]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:55.162]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:55.162]     }
[01:28:55.162]     ...future.result <- base::tryCatch({
[01:28:55.162]         base::withCallingHandlers({
[01:28:55.162]             ...future.value <- base::withVisible(base::local({
[01:28:55.162]                 3
[01:28:55.162]             }))
[01:28:55.162]             future::FutureResult(value = ...future.value$value, 
[01:28:55.162]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:55.162]                   ...future.rng), globalenv = if (FALSE) 
[01:28:55.162]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:55.162]                     ...future.globalenv.names))
[01:28:55.162]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:55.162]         }, condition = base::local({
[01:28:55.162]             c <- base::c
[01:28:55.162]             inherits <- base::inherits
[01:28:55.162]             invokeRestart <- base::invokeRestart
[01:28:55.162]             length <- base::length
[01:28:55.162]             list <- base::list
[01:28:55.162]             seq.int <- base::seq.int
[01:28:55.162]             signalCondition <- base::signalCondition
[01:28:55.162]             sys.calls <- base::sys.calls
[01:28:55.162]             `[[` <- base::`[[`
[01:28:55.162]             `+` <- base::`+`
[01:28:55.162]             `<<-` <- base::`<<-`
[01:28:55.162]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:55.162]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:55.162]                   3L)]
[01:28:55.162]             }
[01:28:55.162]             function(cond) {
[01:28:55.162]                 is_error <- inherits(cond, "error")
[01:28:55.162]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:55.162]                   NULL)
[01:28:55.162]                 if (is_error) {
[01:28:55.162]                   sessionInformation <- function() {
[01:28:55.162]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:55.162]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:55.162]                       search = base::search(), system = base::Sys.info())
[01:28:55.162]                   }
[01:28:55.162]                   ...future.conditions[[length(...future.conditions) + 
[01:28:55.162]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:55.162]                     cond$call), session = sessionInformation(), 
[01:28:55.162]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:55.162]                   signalCondition(cond)
[01:28:55.162]                 }
[01:28:55.162]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:55.162]                 "immediateCondition"))) {
[01:28:55.162]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:55.162]                   ...future.conditions[[length(...future.conditions) + 
[01:28:55.162]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:55.162]                   if (TRUE && !signal) {
[01:28:55.162]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:55.162]                     {
[01:28:55.162]                       inherits <- base::inherits
[01:28:55.162]                       invokeRestart <- base::invokeRestart
[01:28:55.162]                       is.null <- base::is.null
[01:28:55.162]                       muffled <- FALSE
[01:28:55.162]                       if (inherits(cond, "message")) {
[01:28:55.162]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:55.162]                         if (muffled) 
[01:28:55.162]                           invokeRestart("muffleMessage")
[01:28:55.162]                       }
[01:28:55.162]                       else if (inherits(cond, "warning")) {
[01:28:55.162]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:55.162]                         if (muffled) 
[01:28:55.162]                           invokeRestart("muffleWarning")
[01:28:55.162]                       }
[01:28:55.162]                       else if (inherits(cond, "condition")) {
[01:28:55.162]                         if (!is.null(pattern)) {
[01:28:55.162]                           computeRestarts <- base::computeRestarts
[01:28:55.162]                           grepl <- base::grepl
[01:28:55.162]                           restarts <- computeRestarts(cond)
[01:28:55.162]                           for (restart in restarts) {
[01:28:55.162]                             name <- restart$name
[01:28:55.162]                             if (is.null(name)) 
[01:28:55.162]                               next
[01:28:55.162]                             if (!grepl(pattern, name)) 
[01:28:55.162]                               next
[01:28:55.162]                             invokeRestart(restart)
[01:28:55.162]                             muffled <- TRUE
[01:28:55.162]                             break
[01:28:55.162]                           }
[01:28:55.162]                         }
[01:28:55.162]                       }
[01:28:55.162]                       invisible(muffled)
[01:28:55.162]                     }
[01:28:55.162]                     muffleCondition(cond, pattern = "^muffle")
[01:28:55.162]                   }
[01:28:55.162]                 }
[01:28:55.162]                 else {
[01:28:55.162]                   if (TRUE) {
[01:28:55.162]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:55.162]                     {
[01:28:55.162]                       inherits <- base::inherits
[01:28:55.162]                       invokeRestart <- base::invokeRestart
[01:28:55.162]                       is.null <- base::is.null
[01:28:55.162]                       muffled <- FALSE
[01:28:55.162]                       if (inherits(cond, "message")) {
[01:28:55.162]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:55.162]                         if (muffled) 
[01:28:55.162]                           invokeRestart("muffleMessage")
[01:28:55.162]                       }
[01:28:55.162]                       else if (inherits(cond, "warning")) {
[01:28:55.162]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:55.162]                         if (muffled) 
[01:28:55.162]                           invokeRestart("muffleWarning")
[01:28:55.162]                       }
[01:28:55.162]                       else if (inherits(cond, "condition")) {
[01:28:55.162]                         if (!is.null(pattern)) {
[01:28:55.162]                           computeRestarts <- base::computeRestarts
[01:28:55.162]                           grepl <- base::grepl
[01:28:55.162]                           restarts <- computeRestarts(cond)
[01:28:55.162]                           for (restart in restarts) {
[01:28:55.162]                             name <- restart$name
[01:28:55.162]                             if (is.null(name)) 
[01:28:55.162]                               next
[01:28:55.162]                             if (!grepl(pattern, name)) 
[01:28:55.162]                               next
[01:28:55.162]                             invokeRestart(restart)
[01:28:55.162]                             muffled <- TRUE
[01:28:55.162]                             break
[01:28:55.162]                           }
[01:28:55.162]                         }
[01:28:55.162]                       }
[01:28:55.162]                       invisible(muffled)
[01:28:55.162]                     }
[01:28:55.162]                     muffleCondition(cond, pattern = "^muffle")
[01:28:55.162]                   }
[01:28:55.162]                 }
[01:28:55.162]             }
[01:28:55.162]         }))
[01:28:55.162]     }, error = function(ex) {
[01:28:55.162]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:55.162]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:55.162]                 ...future.rng), started = ...future.startTime, 
[01:28:55.162]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:55.162]             version = "1.8"), class = "FutureResult")
[01:28:55.162]     }, finally = {
[01:28:55.162]         if (!identical(...future.workdir, getwd())) 
[01:28:55.162]             setwd(...future.workdir)
[01:28:55.162]         {
[01:28:55.162]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:55.162]                 ...future.oldOptions$nwarnings <- NULL
[01:28:55.162]             }
[01:28:55.162]             base::options(...future.oldOptions)
[01:28:55.162]             if (.Platform$OS.type == "windows") {
[01:28:55.162]                 old_names <- names(...future.oldEnvVars)
[01:28:55.162]                 envs <- base::Sys.getenv()
[01:28:55.162]                 names <- names(envs)
[01:28:55.162]                 common <- intersect(names, old_names)
[01:28:55.162]                 added <- setdiff(names, old_names)
[01:28:55.162]                 removed <- setdiff(old_names, names)
[01:28:55.162]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:55.162]                   envs[common]]
[01:28:55.162]                 NAMES <- toupper(changed)
[01:28:55.162]                 args <- list()
[01:28:55.162]                 for (kk in seq_along(NAMES)) {
[01:28:55.162]                   name <- changed[[kk]]
[01:28:55.162]                   NAME <- NAMES[[kk]]
[01:28:55.162]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:55.162]                     next
[01:28:55.162]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:55.162]                 }
[01:28:55.162]                 NAMES <- toupper(added)
[01:28:55.162]                 for (kk in seq_along(NAMES)) {
[01:28:55.162]                   name <- added[[kk]]
[01:28:55.162]                   NAME <- NAMES[[kk]]
[01:28:55.162]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:55.162]                     next
[01:28:55.162]                   args[[name]] <- ""
[01:28:55.162]                 }
[01:28:55.162]                 NAMES <- toupper(removed)
[01:28:55.162]                 for (kk in seq_along(NAMES)) {
[01:28:55.162]                   name <- removed[[kk]]
[01:28:55.162]                   NAME <- NAMES[[kk]]
[01:28:55.162]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:55.162]                     next
[01:28:55.162]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:55.162]                 }
[01:28:55.162]                 if (length(args) > 0) 
[01:28:55.162]                   base::do.call(base::Sys.setenv, args = args)
[01:28:55.162]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:55.162]             }
[01:28:55.162]             else {
[01:28:55.162]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:55.162]             }
[01:28:55.162]             {
[01:28:55.162]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:55.162]                   0L) {
[01:28:55.162]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:55.162]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:55.162]                   base::options(opts)
[01:28:55.162]                 }
[01:28:55.162]                 {
[01:28:55.162]                   {
[01:28:55.162]                     NULL
[01:28:55.162]                     RNGkind("Mersenne-Twister")
[01:28:55.162]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:55.162]                       inherits = FALSE)
[01:28:55.162]                   }
[01:28:55.162]                   options(future.plan = NULL)
[01:28:55.162]                   if (is.na(NA_character_)) 
[01:28:55.162]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:55.162]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:55.162]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:55.162]                   {
[01:28:55.162]                     future <- SequentialFuture(..., envir = envir)
[01:28:55.162]                     if (!future$lazy) 
[01:28:55.162]                       future <- run(future)
[01:28:55.162]                     invisible(future)
[01:28:55.162]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:55.162]                 }
[01:28:55.162]             }
[01:28:55.162]         }
[01:28:55.162]     })
[01:28:55.162]     if (TRUE) {
[01:28:55.162]         base::sink(type = "output", split = FALSE)
[01:28:55.162]         if (TRUE) {
[01:28:55.162]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:55.162]         }
[01:28:55.162]         else {
[01:28:55.162]             ...future.result["stdout"] <- base::list(NULL)
[01:28:55.162]         }
[01:28:55.162]         base::close(...future.stdout)
[01:28:55.162]         ...future.stdout <- NULL
[01:28:55.162]     }
[01:28:55.162]     ...future.result$conditions <- ...future.conditions
[01:28:55.162]     ...future.result$finished <- base::Sys.time()
[01:28:55.162]     ...future.result
[01:28:55.162] }
[01:28:55.170] plan(): Setting new future strategy stack:
[01:28:55.170] List of future strategies:
[01:28:55.170] 1. sequential:
[01:28:55.170]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:55.170]    - tweaked: FALSE
[01:28:55.170]    - call: NULL
[01:28:55.171] plan(): nbrOfWorkers() = 1
[01:28:55.174] plan(): Setting new future strategy stack:
[01:28:55.174] List of future strategies:
[01:28:55.174] 1. sequential:
[01:28:55.174]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:55.174]    - tweaked: FALSE
[01:28:55.174]    - call: plan(strategy)
[01:28:55.175] plan(): nbrOfWorkers() = 1
[01:28:55.176] SequentialFuture started (and completed)
[01:28:55.176] - Launch lazy future ... done
[01:28:55.177] run() for 'SequentialFuture' ... done
[01:28:55.178] resolve() on list environment ...
[01:28:55.179]  recursive: 0
[01:28:55.180]  length: 4
[01:28:55.180]  elements: 'a', 'b', 'c', 'd'
[01:28:55.180] resolved() for 'SequentialFuture' ...
[01:28:55.181] - state: 'finished'
[01:28:55.181] - run: TRUE
[01:28:55.182] - result: 'FutureResult'
[01:28:55.182] resolved() for 'SequentialFuture' ... done
[01:28:55.182] Future #1
[01:28:55.183]  length: 3 (resolved future 1)
[01:28:55.183] resolved() for 'SequentialFuture' ...
[01:28:55.184] - state: 'finished'
[01:28:55.184] - run: TRUE
[01:28:55.184] - result: 'FutureResult'
[01:28:55.185] resolved() for 'SequentialFuture' ... done
[01:28:55.185] Future #2
[01:28:55.185]  length: 2 (resolved future 2)
[01:28:55.186] resolved() for 'SequentialFuture' ...
[01:28:55.186] - state: 'finished'
[01:28:55.187] - run: TRUE
[01:28:55.187] - result: 'FutureResult'
[01:28:55.187] resolved() for 'SequentialFuture' ... done
[01:28:55.187] Future #3
[01:28:55.188]  length: 1 (resolved future 3)
[01:28:55.188]  length: 0 (resolved future 4)
[01:28:55.188] resolve() on list environment ... DONE
[01:28:55.189] resolved() for 'SequentialFuture' ...
[01:28:55.189] - state: 'finished'
[01:28:55.189] - run: TRUE
[01:28:55.189] - result: 'FutureResult'
[01:28:55.190] resolved() for 'SequentialFuture' ... done
[01:28:55.190] resolve() on list environment ...
[01:28:55.190]  recursive: 0
[01:28:55.191]  length: 4
[01:28:55.192]  elements: 'a', 'b', 'c', 'd'
[01:28:55.192] resolved() for 'SequentialFuture' ...
[01:28:55.192] - state: 'finished'
[01:28:55.193] - run: TRUE
[01:28:55.193] - result: 'FutureResult'
[01:28:55.193] resolved() for 'SequentialFuture' ... done
[01:28:55.193] Future #1
[01:28:55.194]  length: 3 (resolved future 1)
[01:28:55.194] resolved() for 'SequentialFuture' ...
[01:28:55.194] - state: 'finished'
[01:28:55.195] - run: TRUE
[01:28:55.195] - result: 'FutureResult'
[01:28:55.195] resolved() for 'SequentialFuture' ... done
[01:28:55.195] Future #2
[01:28:55.196]  length: 2 (resolved future 2)
[01:28:55.196] resolved() for 'SequentialFuture' ...
[01:28:55.196] - state: 'finished'
[01:28:55.196] - run: TRUE
[01:28:55.197] - result: 'FutureResult'
[01:28:55.197] resolved() for 'SequentialFuture' ... done
[01:28:55.197] Future #3
[01:28:55.197]  length: 1 (resolved future 3)
[01:28:55.198]  length: 0 (resolved future 4)
[01:28:55.198] resolve() on list environment ... DONE
[01:28:55.199] resolve() on list environment ...
[01:28:55.199]  recursive: 0
[01:28:55.200]  length: 4
[01:28:55.201]  elements: 'a', 'b', 'c', 'd'
[01:28:55.201] resolved() for 'SequentialFuture' ...
[01:28:55.201] - state: 'finished'
[01:28:55.201] - run: TRUE
[01:28:55.202] - result: 'FutureResult'
[01:28:55.202] resolved() for 'SequentialFuture' ... done
[01:28:55.202] Future #1
[01:28:55.203]  length: 3 (resolved future 1)
[01:28:55.203] resolved() for 'SequentialFuture' ...
[01:28:55.203] - state: 'finished'
[01:28:55.203] - run: TRUE
[01:28:55.204] - result: 'FutureResult'
[01:28:55.204] resolved() for 'SequentialFuture' ... done
[01:28:55.204] Future #2
[01:28:55.204]  length: 2 (resolved future 2)
[01:28:55.204] resolved() for 'SequentialFuture' ...
[01:28:55.205] - state: 'finished'
[01:28:55.205] - run: TRUE
[01:28:55.205] - result: 'FutureResult'
[01:28:55.205] resolved() for 'SequentialFuture' ... done
[01:28:55.205] Future #3
[01:28:55.206]  length: 1 (resolved future 3)
[01:28:55.206]  length: 0 (resolved future 4)
[01:28:55.206] resolve() on list environment ... DONE
[01:28:55.207] resolve() on list environment ...
[01:28:55.207]  recursive: 0
[01:28:55.208]  length: 4
[01:28:55.208]  elements: 'a', 'b', 'c', 'd'
[01:28:55.209] resolved() for 'SequentialFuture' ...
[01:28:55.209] - state: 'finished'
[01:28:55.209] - run: TRUE
[01:28:55.210] - result: 'FutureResult'
[01:28:55.210] resolved() for 'SequentialFuture' ... done
[01:28:55.210] Future #1
[01:28:55.210]  length: 3 (resolved future 1)
[01:28:55.211] resolved() for 'SequentialFuture' ...
[01:28:55.211] - state: 'finished'
[01:28:55.211] - run: TRUE
[01:28:55.211] - result: 'FutureResult'
[01:28:55.212] resolved() for 'SequentialFuture' ... done
[01:28:55.212] Future #2
[01:28:55.212]  length: 2 (resolved future 2)
[01:28:55.212] resolved() for 'SequentialFuture' ...
[01:28:55.213] - state: 'finished'
[01:28:55.213] - run: TRUE
[01:28:55.213] - result: 'FutureResult'
[01:28:55.216] resolved() for 'SequentialFuture' ... done
[01:28:55.217] Future #3
[01:28:55.217]  length: 1 (resolved future 3)
[01:28:55.217]  length: 0 (resolved future 4)
[01:28:55.217] resolve() on list environment ... DONE
[01:28:55.219] resolve() on list environment ...
[01:28:55.219]  recursive: 0
[01:28:55.221]  length: 4
[01:28:55.222]  elements: 'a', 'b', 'c', 'd'
[01:28:55.222] resolved() for 'SequentialFuture' ...
[01:28:55.222] - state: 'finished'
[01:28:55.223] - run: TRUE
[01:28:55.223] - result: 'FutureResult'
[01:28:55.224] resolved() for 'SequentialFuture' ... done
[01:28:55.224] Future #1
[01:28:55.225]  length: 3 (resolved future 1)
[01:28:55.225] resolved() for 'SequentialFuture' ...
[01:28:55.226] - state: 'finished'
[01:28:55.226] - run: TRUE
[01:28:55.226] - result: 'FutureResult'
[01:28:55.227] resolved() for 'SequentialFuture' ... done
[01:28:55.227] Future #2
[01:28:55.228]  length: 2 (resolved future 2)
[01:28:55.228] resolved() for 'SequentialFuture' ...
[01:28:55.228] - state: 'finished'
[01:28:55.229] - run: TRUE
[01:28:55.229] - result: 'FutureResult'
[01:28:55.230] resolved() for 'SequentialFuture' ... done
[01:28:55.230] Future #3
[01:28:55.231]  length: 1 (resolved future 3)
[01:28:55.231]  length: 0 (resolved future 4)
[01:28:55.232] resolve() on list environment ... DONE
[01:28:55.233] resolve() on list environment ...
[01:28:55.233]  recursive: 99
[01:28:55.235]  length: 4
[01:28:55.235]  elements: 'a', 'b', 'c', 'd'
[01:28:55.236] resolved() for 'SequentialFuture' ...
[01:28:55.236] - state: 'finished'
[01:28:55.237] - run: TRUE
[01:28:55.237] - result: 'FutureResult'
[01:28:55.237] resolved() for 'SequentialFuture' ... done
[01:28:55.238] Future #1
[01:28:55.238] resolved() for 'SequentialFuture' ...
[01:28:55.238] - state: 'finished'
[01:28:55.239] - run: TRUE
[01:28:55.239] - result: 'FutureResult'
[01:28:55.239] resolved() for 'SequentialFuture' ... done
[01:28:55.240] A SequentialFuture was resolved
[01:28:55.240]  length: 3 (resolved future 1)
[01:28:55.241] resolved() for 'SequentialFuture' ...
[01:28:55.241] - state: 'finished'
[01:28:55.241] - run: TRUE
[01:28:55.242] - result: 'FutureResult'
[01:28:55.242] resolved() for 'SequentialFuture' ... done
[01:28:55.242] Future #2
[01:28:55.243] resolved() for 'SequentialFuture' ...
[01:28:55.243] - state: 'finished'
[01:28:55.244] - run: TRUE
[01:28:55.244] - result: 'FutureResult'
[01:28:55.244] resolved() for 'SequentialFuture' ... done
[01:28:55.245] A SequentialFuture was resolved
[01:28:55.245]  length: 2 (resolved future 2)
[01:28:55.246] resolved() for 'SequentialFuture' ...
[01:28:55.246] - state: 'finished'
[01:28:55.247] - run: TRUE
[01:28:55.247] - result: 'FutureResult'
[01:28:55.247] resolved() for 'SequentialFuture' ... done
[01:28:55.248] Future #3
[01:28:55.248] resolved() for 'SequentialFuture' ...
[01:28:55.249] - state: 'finished'
[01:28:55.249] - run: TRUE
[01:28:55.249] - result: 'FutureResult'
[01:28:55.250] resolved() for 'SequentialFuture' ... done
[01:28:55.250] A SequentialFuture was resolved
[01:28:55.251]  length: 1 (resolved future 3)
[01:28:55.251]  length: 0 (resolved future 4)
[01:28:55.251] resolve() on list environment ... DONE
*** resolve() for list environments ... DONE
- plan('sequential') ...
- plan('multisession') ...
[01:28:55.253] plan(): Setting new future strategy stack:
[01:28:55.254] List of future strategies:
[01:28:55.254] 1. multisession:
[01:28:55.254]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[01:28:55.254]    - tweaked: FALSE
[01:28:55.254]    - call: plan(strategy)
[01:28:55.255] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[01:28:55.255] multisession:
[01:28:55.255] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[01:28:55.255] - tweaked: FALSE
[01:28:55.255] - call: plan(strategy)
[01:28:55.264] getGlobalsAndPackages() ...
[01:28:55.265] Not searching for globals
[01:28:55.265] - globals: [0] <none>
[01:28:55.265] getGlobalsAndPackages() ... DONE
[01:28:55.266] [local output] makeClusterPSOCK() ...
[01:28:55.346] [local output] Workers: [n = 2] 'localhost', 'localhost'
[01:28:55.353] [local output] Base port: 25095
[01:28:55.353] [local output] Getting setup options for 2 cluster nodes ...
[01:28:55.354] [local output]  - Node 1 of 2 ...
[01:28:55.355] [local output] localMachine=TRUE => revtunnel=FALSE

[01:28:55.357] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpMRKTUZ/worker.rank=1.parallelly.parent=8824.22785a57ac.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/RtmpMRKTUZ/worker.rank=1.parallelly.parent=8824.22785a57ac.pid\")"'
[01:28:55.687] - Possible to infer worker's PID: TRUE
[01:28:55.688] [local output] Rscript port: 25095

[01:28:55.688] [local output]  - Node 2 of 2 ...
[01:28:55.689] [local output] localMachine=TRUE => revtunnel=FALSE

[01:28:55.691] [local output] Rscript port: 25095

[01:28:55.691] [local output] Getting setup options for 2 cluster nodes ... done
[01:28:55.692] [local output]  - Parallel setup requested for some PSOCK nodes
[01:28:55.693] [local output] Setting up PSOCK nodes in parallel
[01:28:55.693] List of 36
[01:28:55.693]  $ worker          : chr "localhost"
[01:28:55.693]   ..- attr(*, "localhost")= logi TRUE
[01:28:55.693]  $ master          : chr "localhost"
[01:28:55.693]  $ port            : int 25095
[01:28:55.693]  $ connectTimeout  : num 120
[01:28:55.693]  $ timeout         : num 120
[01:28:55.693]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[01:28:55.693]  $ homogeneous     : logi TRUE
[01:28:55.693]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=resolve.R:8824:CRANWIN3:CRAN\" -"| __truncated__
[01:28:55.693]  $ rscript_envs    : NULL
[01:28:55.693]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
[01:28:55.693]  $ rscript_startup : NULL
[01:28:55.693]  $ rscript_sh      : chr "cmd"
[01:28:55.693]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[01:28:55.693]  $ methods         : logi TRUE
[01:28:55.693]  $ socketOptions   : chr "no-delay"
[01:28:55.693]  $ useXDR          : logi FALSE
[01:28:55.693]  $ outfile         : chr "/dev/null"
[01:28:55.693]  $ renice          : int NA
[01:28:55.693]  $ rshcmd          : NULL
[01:28:55.693]  $ user            : chr(0) 
[01:28:55.693]  $ revtunnel       : logi FALSE
[01:28:55.693]  $ rshlogfile      : NULL
[01:28:55.693]  $ rshopts         : chr(0) 
[01:28:55.693]  $ rank            : int 1
[01:28:55.693]  $ manual          : logi FALSE
[01:28:55.693]  $ dryrun          : logi FALSE
[01:28:55.693]  $ quiet           : logi FALSE
[01:28:55.693]  $ setup_strategy  : chr "parallel"
[01:28:55.693]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[01:28:55.693]  $ pidfile         : chr "D:/temp/RtmpMRKTUZ/worker.rank=1.parallelly.parent=8824.22785a57ac.pid"
[01:28:55.693]  $ rshcmd_label    : NULL
[01:28:55.693]  $ rsh_call        : NULL
[01:28:55.693]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[01:28:55.693]  $ localMachine    : logi TRUE
[01:28:55.693]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[01:28:55.693]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[01:28:55.693]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[01:28:55.693]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[01:28:55.693]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[01:28:55.693]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[01:28:55.693]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[01:28:55.693]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[01:28:55.693]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[01:28:55.693]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[01:28:55.693]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[01:28:55.693]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[01:28:55.693]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[01:28:55.693]  $ arguments       :List of 28
[01:28:55.693]   ..$ worker          : chr "localhost"
[01:28:55.693]   ..$ master          : NULL
[01:28:55.693]   ..$ port            : int 25095
[01:28:55.693]   ..$ connectTimeout  : num 120
[01:28:55.693]   ..$ timeout         : num 120
[01:28:55.693]   ..$ rscript         : NULL
[01:28:55.693]   ..$ homogeneous     : NULL
[01:28:55.693]   ..$ rscript_args    : NULL
[01:28:55.693]   ..$ rscript_envs    : NULL
[01:28:55.693]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
[01:28:55.693]   ..$ rscript_startup : NULL
[01:28:55.693]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[01:28:55.693]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[01:28:55.693]   ..$ methods         : logi TRUE
[01:28:55.693]   ..$ socketOptions   : chr "no-delay"
[01:28:55.693]   ..$ useXDR          : logi FALSE
[01:28:55.693]   ..$ outfile         : chr "/dev/null"
[01:28:55.693]   ..$ renice          : int NA
[01:28:55.693]   ..$ rshcmd          : NULL
[01:28:55.693]   ..$ user            : NULL
[01:28:55.693]   ..$ revtunnel       : logi NA
[01:28:55.693]   ..$ rshlogfile      : NULL
[01:28:55.693]   ..$ rshopts         : NULL
[01:28:55.693]   ..$ rank            : int 1
[01:28:55.693]   ..$ manual          : logi FALSE
[01:28:55.693]   ..$ dryrun          : logi FALSE
[01:28:55.693]   ..$ quiet           : logi FALSE
[01:28:55.693]   ..$ setup_strategy  : chr "parallel"
[01:28:55.693]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[01:28:55.722] [local output] System call to launch all workers:
[01:28:55.722] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=resolve.R:8824:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpMRKTUZ/worker.rank=1.parallelly.parent=8824.22785a57ac.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=25095 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[01:28:55.722] [local output] Starting PSOCK main server
[01:28:55.728] [local output] Workers launched
[01:28:55.728] [local output] Waiting for workers to connect back
[01:28:55.729]  - [local output] 0 workers out of 2 ready
[01:28:55.904]  - [local output] 0 workers out of 2 ready
[01:28:55.905]  - [local output] 1 workers out of 2 ready
[01:28:55.906]  - [local output] 2 workers out of 2 ready
[01:28:55.906] [local output] Launching of workers completed
[01:28:55.906] [local output] Collecting session information from workers
[01:28:55.908] [local output]  - Worker #1 of 2
[01:28:55.909] [local output]  - Worker #2 of 2
[01:28:55.909] [local output] makeClusterPSOCK() ... done
[01:28:55.922] Packages needed by the future expression (n = 0): <none>
[01:28:55.923] Packages needed by future strategies (n = 0): <none>
[01:28:55.923] {
[01:28:55.923]     {
[01:28:55.923]         {
[01:28:55.923]             ...future.startTime <- base::Sys.time()
[01:28:55.923]             {
[01:28:55.923]                 {
[01:28:55.923]                   {
[01:28:55.923]                     {
[01:28:55.923]                       base::local({
[01:28:55.923]                         has_future <- base::requireNamespace("future", 
[01:28:55.923]                           quietly = TRUE)
[01:28:55.923]                         if (has_future) {
[01:28:55.923]                           ns <- base::getNamespace("future")
[01:28:55.923]                           version <- ns[[".package"]][["version"]]
[01:28:55.923]                           if (is.null(version)) 
[01:28:55.923]                             version <- utils::packageVersion("future")
[01:28:55.923]                         }
[01:28:55.923]                         else {
[01:28:55.923]                           version <- NULL
[01:28:55.923]                         }
[01:28:55.923]                         if (!has_future || version < "1.8.0") {
[01:28:55.923]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:55.923]                             "", base::R.version$version.string), 
[01:28:55.923]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:55.923]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:55.923]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:55.923]                               "release", "version")], collapse = " "), 
[01:28:55.923]                             hostname = base::Sys.info()[["nodename"]])
[01:28:55.923]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:55.923]                             info)
[01:28:55.923]                           info <- base::paste(info, collapse = "; ")
[01:28:55.923]                           if (!has_future) {
[01:28:55.923]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:55.923]                               info)
[01:28:55.923]                           }
[01:28:55.923]                           else {
[01:28:55.923]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:55.923]                               info, version)
[01:28:55.923]                           }
[01:28:55.923]                           base::stop(msg)
[01:28:55.923]                         }
[01:28:55.923]                       })
[01:28:55.923]                     }
[01:28:55.923]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:55.923]                     base::options(mc.cores = 1L)
[01:28:55.923]                   }
[01:28:55.923]                   options(future.plan = NULL)
[01:28:55.923]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:55.923]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:55.923]                 }
[01:28:55.923]                 ...future.workdir <- getwd()
[01:28:55.923]             }
[01:28:55.923]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:55.923]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:55.923]         }
[01:28:55.923]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:55.923]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:55.923]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:55.923]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:55.923]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:55.923]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:55.923]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:55.923]             base::names(...future.oldOptions))
[01:28:55.923]     }
[01:28:55.923]     if (FALSE) {
[01:28:55.923]     }
[01:28:55.923]     else {
[01:28:55.923]         if (TRUE) {
[01:28:55.923]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:55.923]                 open = "w")
[01:28:55.923]         }
[01:28:55.923]         else {
[01:28:55.923]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:55.923]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:55.923]         }
[01:28:55.923]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:55.923]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:55.923]             base::sink(type = "output", split = FALSE)
[01:28:55.923]             base::close(...future.stdout)
[01:28:55.923]         }, add = TRUE)
[01:28:55.923]     }
[01:28:55.923]     ...future.frame <- base::sys.nframe()
[01:28:55.923]     ...future.conditions <- base::list()
[01:28:55.923]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:55.923]     if (FALSE) {
[01:28:55.923]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:55.923]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:55.923]     }
[01:28:55.923]     ...future.result <- base::tryCatch({
[01:28:55.923]         base::withCallingHandlers({
[01:28:55.923]             ...future.value <- base::withVisible(base::local({
[01:28:55.923]                 ...future.makeSendCondition <- base::local({
[01:28:55.923]                   sendCondition <- NULL
[01:28:55.923]                   function(frame = 1L) {
[01:28:55.923]                     if (is.function(sendCondition)) 
[01:28:55.923]                       return(sendCondition)
[01:28:55.923]                     ns <- getNamespace("parallel")
[01:28:55.923]                     if (exists("sendData", mode = "function", 
[01:28:55.923]                       envir = ns)) {
[01:28:55.923]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:55.923]                         envir = ns)
[01:28:55.923]                       envir <- sys.frame(frame)
[01:28:55.923]                       master <- NULL
[01:28:55.923]                       while (!identical(envir, .GlobalEnv) && 
[01:28:55.923]                         !identical(envir, emptyenv())) {
[01:28:55.923]                         if (exists("master", mode = "list", envir = envir, 
[01:28:55.923]                           inherits = FALSE)) {
[01:28:55.923]                           master <- get("master", mode = "list", 
[01:28:55.923]                             envir = envir, inherits = FALSE)
[01:28:55.923]                           if (inherits(master, c("SOCKnode", 
[01:28:55.923]                             "SOCK0node"))) {
[01:28:55.923]                             sendCondition <<- function(cond) {
[01:28:55.923]                               data <- list(type = "VALUE", value = cond, 
[01:28:55.923]                                 success = TRUE)
[01:28:55.923]                               parallel_sendData(master, data)
[01:28:55.923]                             }
[01:28:55.923]                             return(sendCondition)
[01:28:55.923]                           }
[01:28:55.923]                         }
[01:28:55.923]                         frame <- frame + 1L
[01:28:55.923]                         envir <- sys.frame(frame)
[01:28:55.923]                       }
[01:28:55.923]                     }
[01:28:55.923]                     sendCondition <<- function(cond) NULL
[01:28:55.923]                   }
[01:28:55.923]                 })
[01:28:55.923]                 withCallingHandlers({
[01:28:55.923]                   NA
[01:28:55.923]                 }, immediateCondition = function(cond) {
[01:28:55.923]                   sendCondition <- ...future.makeSendCondition()
[01:28:55.923]                   sendCondition(cond)
[01:28:55.923]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:55.923]                   {
[01:28:55.923]                     inherits <- base::inherits
[01:28:55.923]                     invokeRestart <- base::invokeRestart
[01:28:55.923]                     is.null <- base::is.null
[01:28:55.923]                     muffled <- FALSE
[01:28:55.923]                     if (inherits(cond, "message")) {
[01:28:55.923]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:55.923]                       if (muffled) 
[01:28:55.923]                         invokeRestart("muffleMessage")
[01:28:55.923]                     }
[01:28:55.923]                     else if (inherits(cond, "warning")) {
[01:28:55.923]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:55.923]                       if (muffled) 
[01:28:55.923]                         invokeRestart("muffleWarning")
[01:28:55.923]                     }
[01:28:55.923]                     else if (inherits(cond, "condition")) {
[01:28:55.923]                       if (!is.null(pattern)) {
[01:28:55.923]                         computeRestarts <- base::computeRestarts
[01:28:55.923]                         grepl <- base::grepl
[01:28:55.923]                         restarts <- computeRestarts(cond)
[01:28:55.923]                         for (restart in restarts) {
[01:28:55.923]                           name <- restart$name
[01:28:55.923]                           if (is.null(name)) 
[01:28:55.923]                             next
[01:28:55.923]                           if (!grepl(pattern, name)) 
[01:28:55.923]                             next
[01:28:55.923]                           invokeRestart(restart)
[01:28:55.923]                           muffled <- TRUE
[01:28:55.923]                           break
[01:28:55.923]                         }
[01:28:55.923]                       }
[01:28:55.923]                     }
[01:28:55.923]                     invisible(muffled)
[01:28:55.923]                   }
[01:28:55.923]                   muffleCondition(cond)
[01:28:55.923]                 })
[01:28:55.923]             }))
[01:28:55.923]             future::FutureResult(value = ...future.value$value, 
[01:28:55.923]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:55.923]                   ...future.rng), globalenv = if (FALSE) 
[01:28:55.923]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:55.923]                     ...future.globalenv.names))
[01:28:55.923]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:55.923]         }, condition = base::local({
[01:28:55.923]             c <- base::c
[01:28:55.923]             inherits <- base::inherits
[01:28:55.923]             invokeRestart <- base::invokeRestart
[01:28:55.923]             length <- base::length
[01:28:55.923]             list <- base::list
[01:28:55.923]             seq.int <- base::seq.int
[01:28:55.923]             signalCondition <- base::signalCondition
[01:28:55.923]             sys.calls <- base::sys.calls
[01:28:55.923]             `[[` <- base::`[[`
[01:28:55.923]             `+` <- base::`+`
[01:28:55.923]             `<<-` <- base::`<<-`
[01:28:55.923]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:55.923]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:55.923]                   3L)]
[01:28:55.923]             }
[01:28:55.923]             function(cond) {
[01:28:55.923]                 is_error <- inherits(cond, "error")
[01:28:55.923]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:55.923]                   NULL)
[01:28:55.923]                 if (is_error) {
[01:28:55.923]                   sessionInformation <- function() {
[01:28:55.923]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:55.923]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:55.923]                       search = base::search(), system = base::Sys.info())
[01:28:55.923]                   }
[01:28:55.923]                   ...future.conditions[[length(...future.conditions) + 
[01:28:55.923]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:55.923]                     cond$call), session = sessionInformation(), 
[01:28:55.923]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:55.923]                   signalCondition(cond)
[01:28:55.923]                 }
[01:28:55.923]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:55.923]                 "immediateCondition"))) {
[01:28:55.923]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:55.923]                   ...future.conditions[[length(...future.conditions) + 
[01:28:55.923]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:55.923]                   if (TRUE && !signal) {
[01:28:55.923]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:55.923]                     {
[01:28:55.923]                       inherits <- base::inherits
[01:28:55.923]                       invokeRestart <- base::invokeRestart
[01:28:55.923]                       is.null <- base::is.null
[01:28:55.923]                       muffled <- FALSE
[01:28:55.923]                       if (inherits(cond, "message")) {
[01:28:55.923]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:55.923]                         if (muffled) 
[01:28:55.923]                           invokeRestart("muffleMessage")
[01:28:55.923]                       }
[01:28:55.923]                       else if (inherits(cond, "warning")) {
[01:28:55.923]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:55.923]                         if (muffled) 
[01:28:55.923]                           invokeRestart("muffleWarning")
[01:28:55.923]                       }
[01:28:55.923]                       else if (inherits(cond, "condition")) {
[01:28:55.923]                         if (!is.null(pattern)) {
[01:28:55.923]                           computeRestarts <- base::computeRestarts
[01:28:55.923]                           grepl <- base::grepl
[01:28:55.923]                           restarts <- computeRestarts(cond)
[01:28:55.923]                           for (restart in restarts) {
[01:28:55.923]                             name <- restart$name
[01:28:55.923]                             if (is.null(name)) 
[01:28:55.923]                               next
[01:28:55.923]                             if (!grepl(pattern, name)) 
[01:28:55.923]                               next
[01:28:55.923]                             invokeRestart(restart)
[01:28:55.923]                             muffled <- TRUE
[01:28:55.923]                             break
[01:28:55.923]                           }
[01:28:55.923]                         }
[01:28:55.923]                       }
[01:28:55.923]                       invisible(muffled)
[01:28:55.923]                     }
[01:28:55.923]                     muffleCondition(cond, pattern = "^muffle")
[01:28:55.923]                   }
[01:28:55.923]                 }
[01:28:55.923]                 else {
[01:28:55.923]                   if (TRUE) {
[01:28:55.923]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:55.923]                     {
[01:28:55.923]                       inherits <- base::inherits
[01:28:55.923]                       invokeRestart <- base::invokeRestart
[01:28:55.923]                       is.null <- base::is.null
[01:28:55.923]                       muffled <- FALSE
[01:28:55.923]                       if (inherits(cond, "message")) {
[01:28:55.923]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:55.923]                         if (muffled) 
[01:28:55.923]                           invokeRestart("muffleMessage")
[01:28:55.923]                       }
[01:28:55.923]                       else if (inherits(cond, "warning")) {
[01:28:55.923]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:55.923]                         if (muffled) 
[01:28:55.923]                           invokeRestart("muffleWarning")
[01:28:55.923]                       }
[01:28:55.923]                       else if (inherits(cond, "condition")) {
[01:28:55.923]                         if (!is.null(pattern)) {
[01:28:55.923]                           computeRestarts <- base::computeRestarts
[01:28:55.923]                           grepl <- base::grepl
[01:28:55.923]                           restarts <- computeRestarts(cond)
[01:28:55.923]                           for (restart in restarts) {
[01:28:55.923]                             name <- restart$name
[01:28:55.923]                             if (is.null(name)) 
[01:28:55.923]                               next
[01:28:55.923]                             if (!grepl(pattern, name)) 
[01:28:55.923]                               next
[01:28:55.923]                             invokeRestart(restart)
[01:28:55.923]                             muffled <- TRUE
[01:28:55.923]                             break
[01:28:55.923]                           }
[01:28:55.923]                         }
[01:28:55.923]                       }
[01:28:55.923]                       invisible(muffled)
[01:28:55.923]                     }
[01:28:55.923]                     muffleCondition(cond, pattern = "^muffle")
[01:28:55.923]                   }
[01:28:55.923]                 }
[01:28:55.923]             }
[01:28:55.923]         }))
[01:28:55.923]     }, error = function(ex) {
[01:28:55.923]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:55.923]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:55.923]                 ...future.rng), started = ...future.startTime, 
[01:28:55.923]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:55.923]             version = "1.8"), class = "FutureResult")
[01:28:55.923]     }, finally = {
[01:28:55.923]         if (!identical(...future.workdir, getwd())) 
[01:28:55.923]             setwd(...future.workdir)
[01:28:55.923]         {
[01:28:55.923]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:55.923]                 ...future.oldOptions$nwarnings <- NULL
[01:28:55.923]             }
[01:28:55.923]             base::options(...future.oldOptions)
[01:28:55.923]             if (.Platform$OS.type == "windows") {
[01:28:55.923]                 old_names <- names(...future.oldEnvVars)
[01:28:55.923]                 envs <- base::Sys.getenv()
[01:28:55.923]                 names <- names(envs)
[01:28:55.923]                 common <- intersect(names, old_names)
[01:28:55.923]                 added <- setdiff(names, old_names)
[01:28:55.923]                 removed <- setdiff(old_names, names)
[01:28:55.923]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:55.923]                   envs[common]]
[01:28:55.923]                 NAMES <- toupper(changed)
[01:28:55.923]                 args <- list()
[01:28:55.923]                 for (kk in seq_along(NAMES)) {
[01:28:55.923]                   name <- changed[[kk]]
[01:28:55.923]                   NAME <- NAMES[[kk]]
[01:28:55.923]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:55.923]                     next
[01:28:55.923]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:55.923]                 }
[01:28:55.923]                 NAMES <- toupper(added)
[01:28:55.923]                 for (kk in seq_along(NAMES)) {
[01:28:55.923]                   name <- added[[kk]]
[01:28:55.923]                   NAME <- NAMES[[kk]]
[01:28:55.923]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:55.923]                     next
[01:28:55.923]                   args[[name]] <- ""
[01:28:55.923]                 }
[01:28:55.923]                 NAMES <- toupper(removed)
[01:28:55.923]                 for (kk in seq_along(NAMES)) {
[01:28:55.923]                   name <- removed[[kk]]
[01:28:55.923]                   NAME <- NAMES[[kk]]
[01:28:55.923]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:55.923]                     next
[01:28:55.923]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:55.923]                 }
[01:28:55.923]                 if (length(args) > 0) 
[01:28:55.923]                   base::do.call(base::Sys.setenv, args = args)
[01:28:55.923]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:55.923]             }
[01:28:55.923]             else {
[01:28:55.923]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:55.923]             }
[01:28:55.923]             {
[01:28:55.923]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:55.923]                   0L) {
[01:28:55.923]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:55.923]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:55.923]                   base::options(opts)
[01:28:55.923]                 }
[01:28:55.923]                 {
[01:28:55.923]                   {
[01:28:55.923]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:55.923]                     NULL
[01:28:55.923]                   }
[01:28:55.923]                   options(future.plan = NULL)
[01:28:55.923]                   if (is.na(NA_character_)) 
[01:28:55.923]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:55.923]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:55.923]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:55.923]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:55.923]                     envir = parent.frame()) 
[01:28:55.923]                   {
[01:28:55.923]                     if (is.function(workers)) 
[01:28:55.923]                       workers <- workers()
[01:28:55.923]                     workers <- structure(as.integer(workers), 
[01:28:55.923]                       class = class(workers))
[01:28:55.923]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:55.923]                       workers >= 1)
[01:28:55.923]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:55.923]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:55.923]                     }
[01:28:55.923]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:55.923]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:55.923]                       envir = envir)
[01:28:55.923]                     if (!future$lazy) 
[01:28:55.923]                       future <- run(future)
[01:28:55.923]                     invisible(future)
[01:28:55.923]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:55.923]                 }
[01:28:55.923]             }
[01:28:55.923]         }
[01:28:55.923]     })
[01:28:55.923]     if (TRUE) {
[01:28:55.923]         base::sink(type = "output", split = FALSE)
[01:28:55.923]         if (TRUE) {
[01:28:55.923]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:55.923]         }
[01:28:55.923]         else {
[01:28:55.923]             ...future.result["stdout"] <- base::list(NULL)
[01:28:55.923]         }
[01:28:55.923]         base::close(...future.stdout)
[01:28:55.923]         ...future.stdout <- NULL
[01:28:55.923]     }
[01:28:55.923]     ...future.result$conditions <- ...future.conditions
[01:28:55.923]     ...future.result$finished <- base::Sys.time()
[01:28:55.923]     ...future.result
[01:28:55.923] }
[01:28:56.006] MultisessionFuture started
[01:28:56.006] result() for ClusterFuture ...
[01:28:56.007] receiveMessageFromWorker() for ClusterFuture ...
[01:28:56.007] - Validating connection of MultisessionFuture
[01:28:56.064] - received message: FutureResult
[01:28:56.065] - Received FutureResult
[01:28:56.068] - Erased future from FutureRegistry
[01:28:56.069] result() for ClusterFuture ...
[01:28:56.069] - result already collected: FutureResult
[01:28:56.069] result() for ClusterFuture ... done
[01:28:56.069] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:56.069] result() for ClusterFuture ... done
[01:28:56.070] result() for ClusterFuture ...
[01:28:56.070] - result already collected: FutureResult
[01:28:56.070] result() for ClusterFuture ... done
[01:28:56.070] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[01:28:56.073] plan(): nbrOfWorkers() = 2
*** resolve() for Future objects ...
- result = FALSE, recursive = FALSE ...
[01:28:56.076] getGlobalsAndPackages() ...
[01:28:56.076] Searching for globals...
[01:28:56.078] - globals found: [3] '{', 'Sys.sleep', 'list'
[01:28:56.078] Searching for globals ... DONE
[01:28:56.078] Resolving globals: FALSE
[01:28:56.079] 
[01:28:56.079] 
[01:28:56.079] getGlobalsAndPackages() ... DONE
[01:28:56.080] run() for 'Future' ...
[01:28:56.080] - state: 'created'
[01:28:56.080] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:56.095] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:56.096] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:56.096]   - Field: 'node'
[01:28:56.096]   - Field: 'label'
[01:28:56.096]   - Field: 'local'
[01:28:56.096]   - Field: 'owner'
[01:28:56.097]   - Field: 'envir'
[01:28:56.097]   - Field: 'workers'
[01:28:56.097]   - Field: 'packages'
[01:28:56.097]   - Field: 'gc'
[01:28:56.097]   - Field: 'conditions'
[01:28:56.098]   - Field: 'persistent'
[01:28:56.098]   - Field: 'expr'
[01:28:56.098]   - Field: 'uuid'
[01:28:56.098]   - Field: 'seed'
[01:28:56.098]   - Field: 'version'
[01:28:56.099]   - Field: 'result'
[01:28:56.099]   - Field: 'asynchronous'
[01:28:56.099]   - Field: 'calls'
[01:28:56.099]   - Field: 'globals'
[01:28:56.099]   - Field: 'stdout'
[01:28:56.100]   - Field: 'earlySignal'
[01:28:56.100]   - Field: 'lazy'
[01:28:56.100]   - Field: 'state'
[01:28:56.100] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:56.101] - Launch lazy future ...
[01:28:56.101] Packages needed by the future expression (n = 0): <none>
[01:28:56.101] Packages needed by future strategies (n = 0): <none>
[01:28:56.102] {
[01:28:56.102]     {
[01:28:56.102]         {
[01:28:56.102]             ...future.startTime <- base::Sys.time()
[01:28:56.102]             {
[01:28:56.102]                 {
[01:28:56.102]                   {
[01:28:56.102]                     {
[01:28:56.102]                       base::local({
[01:28:56.102]                         has_future <- base::requireNamespace("future", 
[01:28:56.102]                           quietly = TRUE)
[01:28:56.102]                         if (has_future) {
[01:28:56.102]                           ns <- base::getNamespace("future")
[01:28:56.102]                           version <- ns[[".package"]][["version"]]
[01:28:56.102]                           if (is.null(version)) 
[01:28:56.102]                             version <- utils::packageVersion("future")
[01:28:56.102]                         }
[01:28:56.102]                         else {
[01:28:56.102]                           version <- NULL
[01:28:56.102]                         }
[01:28:56.102]                         if (!has_future || version < "1.8.0") {
[01:28:56.102]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:56.102]                             "", base::R.version$version.string), 
[01:28:56.102]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:56.102]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:56.102]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:56.102]                               "release", "version")], collapse = " "), 
[01:28:56.102]                             hostname = base::Sys.info()[["nodename"]])
[01:28:56.102]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:56.102]                             info)
[01:28:56.102]                           info <- base::paste(info, collapse = "; ")
[01:28:56.102]                           if (!has_future) {
[01:28:56.102]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:56.102]                               info)
[01:28:56.102]                           }
[01:28:56.102]                           else {
[01:28:56.102]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:56.102]                               info, version)
[01:28:56.102]                           }
[01:28:56.102]                           base::stop(msg)
[01:28:56.102]                         }
[01:28:56.102]                       })
[01:28:56.102]                     }
[01:28:56.102]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:56.102]                     base::options(mc.cores = 1L)
[01:28:56.102]                   }
[01:28:56.102]                   options(future.plan = NULL)
[01:28:56.102]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:56.102]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:56.102]                 }
[01:28:56.102]                 ...future.workdir <- getwd()
[01:28:56.102]             }
[01:28:56.102]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:56.102]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:56.102]         }
[01:28:56.102]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:56.102]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:56.102]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:56.102]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:56.102]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:56.102]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:56.102]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:56.102]             base::names(...future.oldOptions))
[01:28:56.102]     }
[01:28:56.102]     if (FALSE) {
[01:28:56.102]     }
[01:28:56.102]     else {
[01:28:56.102]         if (TRUE) {
[01:28:56.102]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:56.102]                 open = "w")
[01:28:56.102]         }
[01:28:56.102]         else {
[01:28:56.102]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:56.102]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:56.102]         }
[01:28:56.102]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:56.102]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:56.102]             base::sink(type = "output", split = FALSE)
[01:28:56.102]             base::close(...future.stdout)
[01:28:56.102]         }, add = TRUE)
[01:28:56.102]     }
[01:28:56.102]     ...future.frame <- base::sys.nframe()
[01:28:56.102]     ...future.conditions <- base::list()
[01:28:56.102]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:56.102]     if (FALSE) {
[01:28:56.102]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:56.102]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:56.102]     }
[01:28:56.102]     ...future.result <- base::tryCatch({
[01:28:56.102]         base::withCallingHandlers({
[01:28:56.102]             ...future.value <- base::withVisible(base::local({
[01:28:56.102]                 ...future.makeSendCondition <- base::local({
[01:28:56.102]                   sendCondition <- NULL
[01:28:56.102]                   function(frame = 1L) {
[01:28:56.102]                     if (is.function(sendCondition)) 
[01:28:56.102]                       return(sendCondition)
[01:28:56.102]                     ns <- getNamespace("parallel")
[01:28:56.102]                     if (exists("sendData", mode = "function", 
[01:28:56.102]                       envir = ns)) {
[01:28:56.102]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:56.102]                         envir = ns)
[01:28:56.102]                       envir <- sys.frame(frame)
[01:28:56.102]                       master <- NULL
[01:28:56.102]                       while (!identical(envir, .GlobalEnv) && 
[01:28:56.102]                         !identical(envir, emptyenv())) {
[01:28:56.102]                         if (exists("master", mode = "list", envir = envir, 
[01:28:56.102]                           inherits = FALSE)) {
[01:28:56.102]                           master <- get("master", mode = "list", 
[01:28:56.102]                             envir = envir, inherits = FALSE)
[01:28:56.102]                           if (inherits(master, c("SOCKnode", 
[01:28:56.102]                             "SOCK0node"))) {
[01:28:56.102]                             sendCondition <<- function(cond) {
[01:28:56.102]                               data <- list(type = "VALUE", value = cond, 
[01:28:56.102]                                 success = TRUE)
[01:28:56.102]                               parallel_sendData(master, data)
[01:28:56.102]                             }
[01:28:56.102]                             return(sendCondition)
[01:28:56.102]                           }
[01:28:56.102]                         }
[01:28:56.102]                         frame <- frame + 1L
[01:28:56.102]                         envir <- sys.frame(frame)
[01:28:56.102]                       }
[01:28:56.102]                     }
[01:28:56.102]                     sendCondition <<- function(cond) NULL
[01:28:56.102]                   }
[01:28:56.102]                 })
[01:28:56.102]                 withCallingHandlers({
[01:28:56.102]                   {
[01:28:56.102]                     Sys.sleep(0.5)
[01:28:56.102]                     list(a = 1, b = 42L)
[01:28:56.102]                   }
[01:28:56.102]                 }, immediateCondition = function(cond) {
[01:28:56.102]                   sendCondition <- ...future.makeSendCondition()
[01:28:56.102]                   sendCondition(cond)
[01:28:56.102]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:56.102]                   {
[01:28:56.102]                     inherits <- base::inherits
[01:28:56.102]                     invokeRestart <- base::invokeRestart
[01:28:56.102]                     is.null <- base::is.null
[01:28:56.102]                     muffled <- FALSE
[01:28:56.102]                     if (inherits(cond, "message")) {
[01:28:56.102]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:56.102]                       if (muffled) 
[01:28:56.102]                         invokeRestart("muffleMessage")
[01:28:56.102]                     }
[01:28:56.102]                     else if (inherits(cond, "warning")) {
[01:28:56.102]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:56.102]                       if (muffled) 
[01:28:56.102]                         invokeRestart("muffleWarning")
[01:28:56.102]                     }
[01:28:56.102]                     else if (inherits(cond, "condition")) {
[01:28:56.102]                       if (!is.null(pattern)) {
[01:28:56.102]                         computeRestarts <- base::computeRestarts
[01:28:56.102]                         grepl <- base::grepl
[01:28:56.102]                         restarts <- computeRestarts(cond)
[01:28:56.102]                         for (restart in restarts) {
[01:28:56.102]                           name <- restart$name
[01:28:56.102]                           if (is.null(name)) 
[01:28:56.102]                             next
[01:28:56.102]                           if (!grepl(pattern, name)) 
[01:28:56.102]                             next
[01:28:56.102]                           invokeRestart(restart)
[01:28:56.102]                           muffled <- TRUE
[01:28:56.102]                           break
[01:28:56.102]                         }
[01:28:56.102]                       }
[01:28:56.102]                     }
[01:28:56.102]                     invisible(muffled)
[01:28:56.102]                   }
[01:28:56.102]                   muffleCondition(cond)
[01:28:56.102]                 })
[01:28:56.102]             }))
[01:28:56.102]             future::FutureResult(value = ...future.value$value, 
[01:28:56.102]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:56.102]                   ...future.rng), globalenv = if (FALSE) 
[01:28:56.102]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:56.102]                     ...future.globalenv.names))
[01:28:56.102]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:56.102]         }, condition = base::local({
[01:28:56.102]             c <- base::c
[01:28:56.102]             inherits <- base::inherits
[01:28:56.102]             invokeRestart <- base::invokeRestart
[01:28:56.102]             length <- base::length
[01:28:56.102]             list <- base::list
[01:28:56.102]             seq.int <- base::seq.int
[01:28:56.102]             signalCondition <- base::signalCondition
[01:28:56.102]             sys.calls <- base::sys.calls
[01:28:56.102]             `[[` <- base::`[[`
[01:28:56.102]             `+` <- base::`+`
[01:28:56.102]             `<<-` <- base::`<<-`
[01:28:56.102]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:56.102]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:56.102]                   3L)]
[01:28:56.102]             }
[01:28:56.102]             function(cond) {
[01:28:56.102]                 is_error <- inherits(cond, "error")
[01:28:56.102]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:56.102]                   NULL)
[01:28:56.102]                 if (is_error) {
[01:28:56.102]                   sessionInformation <- function() {
[01:28:56.102]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:56.102]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:56.102]                       search = base::search(), system = base::Sys.info())
[01:28:56.102]                   }
[01:28:56.102]                   ...future.conditions[[length(...future.conditions) + 
[01:28:56.102]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:56.102]                     cond$call), session = sessionInformation(), 
[01:28:56.102]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:56.102]                   signalCondition(cond)
[01:28:56.102]                 }
[01:28:56.102]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:56.102]                 "immediateCondition"))) {
[01:28:56.102]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:56.102]                   ...future.conditions[[length(...future.conditions) + 
[01:28:56.102]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:56.102]                   if (TRUE && !signal) {
[01:28:56.102]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:56.102]                     {
[01:28:56.102]                       inherits <- base::inherits
[01:28:56.102]                       invokeRestart <- base::invokeRestart
[01:28:56.102]                       is.null <- base::is.null
[01:28:56.102]                       muffled <- FALSE
[01:28:56.102]                       if (inherits(cond, "message")) {
[01:28:56.102]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:56.102]                         if (muffled) 
[01:28:56.102]                           invokeRestart("muffleMessage")
[01:28:56.102]                       }
[01:28:56.102]                       else if (inherits(cond, "warning")) {
[01:28:56.102]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:56.102]                         if (muffled) 
[01:28:56.102]                           invokeRestart("muffleWarning")
[01:28:56.102]                       }
[01:28:56.102]                       else if (inherits(cond, "condition")) {
[01:28:56.102]                         if (!is.null(pattern)) {
[01:28:56.102]                           computeRestarts <- base::computeRestarts
[01:28:56.102]                           grepl <- base::grepl
[01:28:56.102]                           restarts <- computeRestarts(cond)
[01:28:56.102]                           for (restart in restarts) {
[01:28:56.102]                             name <- restart$name
[01:28:56.102]                             if (is.null(name)) 
[01:28:56.102]                               next
[01:28:56.102]                             if (!grepl(pattern, name)) 
[01:28:56.102]                               next
[01:28:56.102]                             invokeRestart(restart)
[01:28:56.102]                             muffled <- TRUE
[01:28:56.102]                             break
[01:28:56.102]                           }
[01:28:56.102]                         }
[01:28:56.102]                       }
[01:28:56.102]                       invisible(muffled)
[01:28:56.102]                     }
[01:28:56.102]                     muffleCondition(cond, pattern = "^muffle")
[01:28:56.102]                   }
[01:28:56.102]                 }
[01:28:56.102]                 else {
[01:28:56.102]                   if (TRUE) {
[01:28:56.102]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:56.102]                     {
[01:28:56.102]                       inherits <- base::inherits
[01:28:56.102]                       invokeRestart <- base::invokeRestart
[01:28:56.102]                       is.null <- base::is.null
[01:28:56.102]                       muffled <- FALSE
[01:28:56.102]                       if (inherits(cond, "message")) {
[01:28:56.102]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:56.102]                         if (muffled) 
[01:28:56.102]                           invokeRestart("muffleMessage")
[01:28:56.102]                       }
[01:28:56.102]                       else if (inherits(cond, "warning")) {
[01:28:56.102]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:56.102]                         if (muffled) 
[01:28:56.102]                           invokeRestart("muffleWarning")
[01:28:56.102]                       }
[01:28:56.102]                       else if (inherits(cond, "condition")) {
[01:28:56.102]                         if (!is.null(pattern)) {
[01:28:56.102]                           computeRestarts <- base::computeRestarts
[01:28:56.102]                           grepl <- base::grepl
[01:28:56.102]                           restarts <- computeRestarts(cond)
[01:28:56.102]                           for (restart in restarts) {
[01:28:56.102]                             name <- restart$name
[01:28:56.102]                             if (is.null(name)) 
[01:28:56.102]                               next
[01:28:56.102]                             if (!grepl(pattern, name)) 
[01:28:56.102]                               next
[01:28:56.102]                             invokeRestart(restart)
[01:28:56.102]                             muffled <- TRUE
[01:28:56.102]                             break
[01:28:56.102]                           }
[01:28:56.102]                         }
[01:28:56.102]                       }
[01:28:56.102]                       invisible(muffled)
[01:28:56.102]                     }
[01:28:56.102]                     muffleCondition(cond, pattern = "^muffle")
[01:28:56.102]                   }
[01:28:56.102]                 }
[01:28:56.102]             }
[01:28:56.102]         }))
[01:28:56.102]     }, error = function(ex) {
[01:28:56.102]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:56.102]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:56.102]                 ...future.rng), started = ...future.startTime, 
[01:28:56.102]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:56.102]             version = "1.8"), class = "FutureResult")
[01:28:56.102]     }, finally = {
[01:28:56.102]         if (!identical(...future.workdir, getwd())) 
[01:28:56.102]             setwd(...future.workdir)
[01:28:56.102]         {
[01:28:56.102]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:56.102]                 ...future.oldOptions$nwarnings <- NULL
[01:28:56.102]             }
[01:28:56.102]             base::options(...future.oldOptions)
[01:28:56.102]             if (.Platform$OS.type == "windows") {
[01:28:56.102]                 old_names <- names(...future.oldEnvVars)
[01:28:56.102]                 envs <- base::Sys.getenv()
[01:28:56.102]                 names <- names(envs)
[01:28:56.102]                 common <- intersect(names, old_names)
[01:28:56.102]                 added <- setdiff(names, old_names)
[01:28:56.102]                 removed <- setdiff(old_names, names)
[01:28:56.102]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:56.102]                   envs[common]]
[01:28:56.102]                 NAMES <- toupper(changed)
[01:28:56.102]                 args <- list()
[01:28:56.102]                 for (kk in seq_along(NAMES)) {
[01:28:56.102]                   name <- changed[[kk]]
[01:28:56.102]                   NAME <- NAMES[[kk]]
[01:28:56.102]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:56.102]                     next
[01:28:56.102]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:56.102]                 }
[01:28:56.102]                 NAMES <- toupper(added)
[01:28:56.102]                 for (kk in seq_along(NAMES)) {
[01:28:56.102]                   name <- added[[kk]]
[01:28:56.102]                   NAME <- NAMES[[kk]]
[01:28:56.102]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:56.102]                     next
[01:28:56.102]                   args[[name]] <- ""
[01:28:56.102]                 }
[01:28:56.102]                 NAMES <- toupper(removed)
[01:28:56.102]                 for (kk in seq_along(NAMES)) {
[01:28:56.102]                   name <- removed[[kk]]
[01:28:56.102]                   NAME <- NAMES[[kk]]
[01:28:56.102]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:56.102]                     next
[01:28:56.102]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:56.102]                 }
[01:28:56.102]                 if (length(args) > 0) 
[01:28:56.102]                   base::do.call(base::Sys.setenv, args = args)
[01:28:56.102]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:56.102]             }
[01:28:56.102]             else {
[01:28:56.102]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:56.102]             }
[01:28:56.102]             {
[01:28:56.102]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:56.102]                   0L) {
[01:28:56.102]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:56.102]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:56.102]                   base::options(opts)
[01:28:56.102]                 }
[01:28:56.102]                 {
[01:28:56.102]                   {
[01:28:56.102]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:56.102]                     NULL
[01:28:56.102]                   }
[01:28:56.102]                   options(future.plan = NULL)
[01:28:56.102]                   if (is.na(NA_character_)) 
[01:28:56.102]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:56.102]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:56.102]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:56.102]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:56.102]                     envir = parent.frame()) 
[01:28:56.102]                   {
[01:28:56.102]                     if (is.function(workers)) 
[01:28:56.102]                       workers <- workers()
[01:28:56.102]                     workers <- structure(as.integer(workers), 
[01:28:56.102]                       class = class(workers))
[01:28:56.102]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:56.102]                       workers >= 1)
[01:28:56.102]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:56.102]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:56.102]                     }
[01:28:56.102]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:56.102]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:56.102]                       envir = envir)
[01:28:56.102]                     if (!future$lazy) 
[01:28:56.102]                       future <- run(future)
[01:28:56.102]                     invisible(future)
[01:28:56.102]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:56.102]                 }
[01:28:56.102]             }
[01:28:56.102]         }
[01:28:56.102]     })
[01:28:56.102]     if (TRUE) {
[01:28:56.102]         base::sink(type = "output", split = FALSE)
[01:28:56.102]         if (TRUE) {
[01:28:56.102]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:56.102]         }
[01:28:56.102]         else {
[01:28:56.102]             ...future.result["stdout"] <- base::list(NULL)
[01:28:56.102]         }
[01:28:56.102]         base::close(...future.stdout)
[01:28:56.102]         ...future.stdout <- NULL
[01:28:56.102]     }
[01:28:56.102]     ...future.result$conditions <- ...future.conditions
[01:28:56.102]     ...future.result$finished <- base::Sys.time()
[01:28:56.102]     ...future.result
[01:28:56.102] }
[01:28:56.108] MultisessionFuture started
[01:28:56.109] - Launch lazy future ... done
[01:28:56.109] run() for 'MultisessionFuture' ... done
[01:28:56.643] receiveMessageFromWorker() for ClusterFuture ...
[01:28:56.643] - Validating connection of MultisessionFuture
[01:28:56.644] - received message: FutureResult
[01:28:56.644] - Received FutureResult
[01:28:56.644] - Erased future from FutureRegistry
[01:28:56.644] result() for ClusterFuture ...
[01:28:56.645] - result already collected: FutureResult
[01:28:56.645] result() for ClusterFuture ... done
[01:28:56.645] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:56.645] A MultisessionFuture was resolved (result was not collected)
[01:28:56.645] getGlobalsAndPackages() ...
[01:28:56.646] Searching for globals...
[01:28:56.647] - globals found: [3] '{', 'Sys.sleep', 'list'
[01:28:56.648] Searching for globals ... DONE
[01:28:56.648] Resolving globals: FALSE
[01:28:56.648] 
[01:28:56.649] 
[01:28:56.649] getGlobalsAndPackages() ... DONE
[01:28:56.649] run() for 'Future' ...
[01:28:56.649] - state: 'created'
[01:28:56.650] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:56.665] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:56.665] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:56.665]   - Field: 'node'
[01:28:56.665]   - Field: 'label'
[01:28:56.666]   - Field: 'local'
[01:28:56.666]   - Field: 'owner'
[01:28:56.666]   - Field: 'envir'
[01:28:56.666]   - Field: 'workers'
[01:28:56.666]   - Field: 'packages'
[01:28:56.667]   - Field: 'gc'
[01:28:56.667]   - Field: 'conditions'
[01:28:56.667]   - Field: 'persistent'
[01:28:56.667]   - Field: 'expr'
[01:28:56.667]   - Field: 'uuid'
[01:28:56.668]   - Field: 'seed'
[01:28:56.668]   - Field: 'version'
[01:28:56.668]   - Field: 'result'
[01:28:56.668]   - Field: 'asynchronous'
[01:28:56.668]   - Field: 'calls'
[01:28:56.669]   - Field: 'globals'
[01:28:56.669]   - Field: 'stdout'
[01:28:56.669]   - Field: 'earlySignal'
[01:28:56.669]   - Field: 'lazy'
[01:28:56.669]   - Field: 'state'
[01:28:56.670] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:56.670] - Launch lazy future ...
[01:28:56.670] Packages needed by the future expression (n = 0): <none>
[01:28:56.671] Packages needed by future strategies (n = 0): <none>
[01:28:56.671] {
[01:28:56.671]     {
[01:28:56.671]         {
[01:28:56.671]             ...future.startTime <- base::Sys.time()
[01:28:56.671]             {
[01:28:56.671]                 {
[01:28:56.671]                   {
[01:28:56.671]                     {
[01:28:56.671]                       base::local({
[01:28:56.671]                         has_future <- base::requireNamespace("future", 
[01:28:56.671]                           quietly = TRUE)
[01:28:56.671]                         if (has_future) {
[01:28:56.671]                           ns <- base::getNamespace("future")
[01:28:56.671]                           version <- ns[[".package"]][["version"]]
[01:28:56.671]                           if (is.null(version)) 
[01:28:56.671]                             version <- utils::packageVersion("future")
[01:28:56.671]                         }
[01:28:56.671]                         else {
[01:28:56.671]                           version <- NULL
[01:28:56.671]                         }
[01:28:56.671]                         if (!has_future || version < "1.8.0") {
[01:28:56.671]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:56.671]                             "", base::R.version$version.string), 
[01:28:56.671]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:56.671]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:56.671]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:56.671]                               "release", "version")], collapse = " "), 
[01:28:56.671]                             hostname = base::Sys.info()[["nodename"]])
[01:28:56.671]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:56.671]                             info)
[01:28:56.671]                           info <- base::paste(info, collapse = "; ")
[01:28:56.671]                           if (!has_future) {
[01:28:56.671]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:56.671]                               info)
[01:28:56.671]                           }
[01:28:56.671]                           else {
[01:28:56.671]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:56.671]                               info, version)
[01:28:56.671]                           }
[01:28:56.671]                           base::stop(msg)
[01:28:56.671]                         }
[01:28:56.671]                       })
[01:28:56.671]                     }
[01:28:56.671]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:56.671]                     base::options(mc.cores = 1L)
[01:28:56.671]                   }
[01:28:56.671]                   options(future.plan = NULL)
[01:28:56.671]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:56.671]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:56.671]                 }
[01:28:56.671]                 ...future.workdir <- getwd()
[01:28:56.671]             }
[01:28:56.671]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:56.671]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:56.671]         }
[01:28:56.671]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:56.671]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:56.671]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:56.671]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:56.671]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:56.671]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:56.671]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:56.671]             base::names(...future.oldOptions))
[01:28:56.671]     }
[01:28:56.671]     if (FALSE) {
[01:28:56.671]     }
[01:28:56.671]     else {
[01:28:56.671]         if (TRUE) {
[01:28:56.671]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:56.671]                 open = "w")
[01:28:56.671]         }
[01:28:56.671]         else {
[01:28:56.671]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:56.671]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:56.671]         }
[01:28:56.671]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:56.671]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:56.671]             base::sink(type = "output", split = FALSE)
[01:28:56.671]             base::close(...future.stdout)
[01:28:56.671]         }, add = TRUE)
[01:28:56.671]     }
[01:28:56.671]     ...future.frame <- base::sys.nframe()
[01:28:56.671]     ...future.conditions <- base::list()
[01:28:56.671]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:56.671]     if (FALSE) {
[01:28:56.671]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:56.671]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:56.671]     }
[01:28:56.671]     ...future.result <- base::tryCatch({
[01:28:56.671]         base::withCallingHandlers({
[01:28:56.671]             ...future.value <- base::withVisible(base::local({
[01:28:56.671]                 ...future.makeSendCondition <- base::local({
[01:28:56.671]                   sendCondition <- NULL
[01:28:56.671]                   function(frame = 1L) {
[01:28:56.671]                     if (is.function(sendCondition)) 
[01:28:56.671]                       return(sendCondition)
[01:28:56.671]                     ns <- getNamespace("parallel")
[01:28:56.671]                     if (exists("sendData", mode = "function", 
[01:28:56.671]                       envir = ns)) {
[01:28:56.671]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:56.671]                         envir = ns)
[01:28:56.671]                       envir <- sys.frame(frame)
[01:28:56.671]                       master <- NULL
[01:28:56.671]                       while (!identical(envir, .GlobalEnv) && 
[01:28:56.671]                         !identical(envir, emptyenv())) {
[01:28:56.671]                         if (exists("master", mode = "list", envir = envir, 
[01:28:56.671]                           inherits = FALSE)) {
[01:28:56.671]                           master <- get("master", mode = "list", 
[01:28:56.671]                             envir = envir, inherits = FALSE)
[01:28:56.671]                           if (inherits(master, c("SOCKnode", 
[01:28:56.671]                             "SOCK0node"))) {
[01:28:56.671]                             sendCondition <<- function(cond) {
[01:28:56.671]                               data <- list(type = "VALUE", value = cond, 
[01:28:56.671]                                 success = TRUE)
[01:28:56.671]                               parallel_sendData(master, data)
[01:28:56.671]                             }
[01:28:56.671]                             return(sendCondition)
[01:28:56.671]                           }
[01:28:56.671]                         }
[01:28:56.671]                         frame <- frame + 1L
[01:28:56.671]                         envir <- sys.frame(frame)
[01:28:56.671]                       }
[01:28:56.671]                     }
[01:28:56.671]                     sendCondition <<- function(cond) NULL
[01:28:56.671]                   }
[01:28:56.671]                 })
[01:28:56.671]                 withCallingHandlers({
[01:28:56.671]                   {
[01:28:56.671]                     Sys.sleep(0.5)
[01:28:56.671]                     list(a = 1, b = 42L)
[01:28:56.671]                   }
[01:28:56.671]                 }, immediateCondition = function(cond) {
[01:28:56.671]                   sendCondition <- ...future.makeSendCondition()
[01:28:56.671]                   sendCondition(cond)
[01:28:56.671]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:56.671]                   {
[01:28:56.671]                     inherits <- base::inherits
[01:28:56.671]                     invokeRestart <- base::invokeRestart
[01:28:56.671]                     is.null <- base::is.null
[01:28:56.671]                     muffled <- FALSE
[01:28:56.671]                     if (inherits(cond, "message")) {
[01:28:56.671]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:56.671]                       if (muffled) 
[01:28:56.671]                         invokeRestart("muffleMessage")
[01:28:56.671]                     }
[01:28:56.671]                     else if (inherits(cond, "warning")) {
[01:28:56.671]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:56.671]                       if (muffled) 
[01:28:56.671]                         invokeRestart("muffleWarning")
[01:28:56.671]                     }
[01:28:56.671]                     else if (inherits(cond, "condition")) {
[01:28:56.671]                       if (!is.null(pattern)) {
[01:28:56.671]                         computeRestarts <- base::computeRestarts
[01:28:56.671]                         grepl <- base::grepl
[01:28:56.671]                         restarts <- computeRestarts(cond)
[01:28:56.671]                         for (restart in restarts) {
[01:28:56.671]                           name <- restart$name
[01:28:56.671]                           if (is.null(name)) 
[01:28:56.671]                             next
[01:28:56.671]                           if (!grepl(pattern, name)) 
[01:28:56.671]                             next
[01:28:56.671]                           invokeRestart(restart)
[01:28:56.671]                           muffled <- TRUE
[01:28:56.671]                           break
[01:28:56.671]                         }
[01:28:56.671]                       }
[01:28:56.671]                     }
[01:28:56.671]                     invisible(muffled)
[01:28:56.671]                   }
[01:28:56.671]                   muffleCondition(cond)
[01:28:56.671]                 })
[01:28:56.671]             }))
[01:28:56.671]             future::FutureResult(value = ...future.value$value, 
[01:28:56.671]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:56.671]                   ...future.rng), globalenv = if (FALSE) 
[01:28:56.671]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:56.671]                     ...future.globalenv.names))
[01:28:56.671]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:56.671]         }, condition = base::local({
[01:28:56.671]             c <- base::c
[01:28:56.671]             inherits <- base::inherits
[01:28:56.671]             invokeRestart <- base::invokeRestart
[01:28:56.671]             length <- base::length
[01:28:56.671]             list <- base::list
[01:28:56.671]             seq.int <- base::seq.int
[01:28:56.671]             signalCondition <- base::signalCondition
[01:28:56.671]             sys.calls <- base::sys.calls
[01:28:56.671]             `[[` <- base::`[[`
[01:28:56.671]             `+` <- base::`+`
[01:28:56.671]             `<<-` <- base::`<<-`
[01:28:56.671]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:56.671]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:56.671]                   3L)]
[01:28:56.671]             }
[01:28:56.671]             function(cond) {
[01:28:56.671]                 is_error <- inherits(cond, "error")
[01:28:56.671]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:56.671]                   NULL)
[01:28:56.671]                 if (is_error) {
[01:28:56.671]                   sessionInformation <- function() {
[01:28:56.671]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:56.671]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:56.671]                       search = base::search(), system = base::Sys.info())
[01:28:56.671]                   }
[01:28:56.671]                   ...future.conditions[[length(...future.conditions) + 
[01:28:56.671]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:56.671]                     cond$call), session = sessionInformation(), 
[01:28:56.671]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:56.671]                   signalCondition(cond)
[01:28:56.671]                 }
[01:28:56.671]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:56.671]                 "immediateCondition"))) {
[01:28:56.671]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:56.671]                   ...future.conditions[[length(...future.conditions) + 
[01:28:56.671]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:56.671]                   if (TRUE && !signal) {
[01:28:56.671]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:56.671]                     {
[01:28:56.671]                       inherits <- base::inherits
[01:28:56.671]                       invokeRestart <- base::invokeRestart
[01:28:56.671]                       is.null <- base::is.null
[01:28:56.671]                       muffled <- FALSE
[01:28:56.671]                       if (inherits(cond, "message")) {
[01:28:56.671]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:56.671]                         if (muffled) 
[01:28:56.671]                           invokeRestart("muffleMessage")
[01:28:56.671]                       }
[01:28:56.671]                       else if (inherits(cond, "warning")) {
[01:28:56.671]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:56.671]                         if (muffled) 
[01:28:56.671]                           invokeRestart("muffleWarning")
[01:28:56.671]                       }
[01:28:56.671]                       else if (inherits(cond, "condition")) {
[01:28:56.671]                         if (!is.null(pattern)) {
[01:28:56.671]                           computeRestarts <- base::computeRestarts
[01:28:56.671]                           grepl <- base::grepl
[01:28:56.671]                           restarts <- computeRestarts(cond)
[01:28:56.671]                           for (restart in restarts) {
[01:28:56.671]                             name <- restart$name
[01:28:56.671]                             if (is.null(name)) 
[01:28:56.671]                               next
[01:28:56.671]                             if (!grepl(pattern, name)) 
[01:28:56.671]                               next
[01:28:56.671]                             invokeRestart(restart)
[01:28:56.671]                             muffled <- TRUE
[01:28:56.671]                             break
[01:28:56.671]                           }
[01:28:56.671]                         }
[01:28:56.671]                       }
[01:28:56.671]                       invisible(muffled)
[01:28:56.671]                     }
[01:28:56.671]                     muffleCondition(cond, pattern = "^muffle")
[01:28:56.671]                   }
[01:28:56.671]                 }
[01:28:56.671]                 else {
[01:28:56.671]                   if (TRUE) {
[01:28:56.671]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:56.671]                     {
[01:28:56.671]                       inherits <- base::inherits
[01:28:56.671]                       invokeRestart <- base::invokeRestart
[01:28:56.671]                       is.null <- base::is.null
[01:28:56.671]                       muffled <- FALSE
[01:28:56.671]                       if (inherits(cond, "message")) {
[01:28:56.671]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:56.671]                         if (muffled) 
[01:28:56.671]                           invokeRestart("muffleMessage")
[01:28:56.671]                       }
[01:28:56.671]                       else if (inherits(cond, "warning")) {
[01:28:56.671]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:56.671]                         if (muffled) 
[01:28:56.671]                           invokeRestart("muffleWarning")
[01:28:56.671]                       }
[01:28:56.671]                       else if (inherits(cond, "condition")) {
[01:28:56.671]                         if (!is.null(pattern)) {
[01:28:56.671]                           computeRestarts <- base::computeRestarts
[01:28:56.671]                           grepl <- base::grepl
[01:28:56.671]                           restarts <- computeRestarts(cond)
[01:28:56.671]                           for (restart in restarts) {
[01:28:56.671]                             name <- restart$name
[01:28:56.671]                             if (is.null(name)) 
[01:28:56.671]                               next
[01:28:56.671]                             if (!grepl(pattern, name)) 
[01:28:56.671]                               next
[01:28:56.671]                             invokeRestart(restart)
[01:28:56.671]                             muffled <- TRUE
[01:28:56.671]                             break
[01:28:56.671]                           }
[01:28:56.671]                         }
[01:28:56.671]                       }
[01:28:56.671]                       invisible(muffled)
[01:28:56.671]                     }
[01:28:56.671]                     muffleCondition(cond, pattern = "^muffle")
[01:28:56.671]                   }
[01:28:56.671]                 }
[01:28:56.671]             }
[01:28:56.671]         }))
[01:28:56.671]     }, error = function(ex) {
[01:28:56.671]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:56.671]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:56.671]                 ...future.rng), started = ...future.startTime, 
[01:28:56.671]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:56.671]             version = "1.8"), class = "FutureResult")
[01:28:56.671]     }, finally = {
[01:28:56.671]         if (!identical(...future.workdir, getwd())) 
[01:28:56.671]             setwd(...future.workdir)
[01:28:56.671]         {
[01:28:56.671]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:56.671]                 ...future.oldOptions$nwarnings <- NULL
[01:28:56.671]             }
[01:28:56.671]             base::options(...future.oldOptions)
[01:28:56.671]             if (.Platform$OS.type == "windows") {
[01:28:56.671]                 old_names <- names(...future.oldEnvVars)
[01:28:56.671]                 envs <- base::Sys.getenv()
[01:28:56.671]                 names <- names(envs)
[01:28:56.671]                 common <- intersect(names, old_names)
[01:28:56.671]                 added <- setdiff(names, old_names)
[01:28:56.671]                 removed <- setdiff(old_names, names)
[01:28:56.671]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:56.671]                   envs[common]]
[01:28:56.671]                 NAMES <- toupper(changed)
[01:28:56.671]                 args <- list()
[01:28:56.671]                 for (kk in seq_along(NAMES)) {
[01:28:56.671]                   name <- changed[[kk]]
[01:28:56.671]                   NAME <- NAMES[[kk]]
[01:28:56.671]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:56.671]                     next
[01:28:56.671]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:56.671]                 }
[01:28:56.671]                 NAMES <- toupper(added)
[01:28:56.671]                 for (kk in seq_along(NAMES)) {
[01:28:56.671]                   name <- added[[kk]]
[01:28:56.671]                   NAME <- NAMES[[kk]]
[01:28:56.671]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:56.671]                     next
[01:28:56.671]                   args[[name]] <- ""
[01:28:56.671]                 }
[01:28:56.671]                 NAMES <- toupper(removed)
[01:28:56.671]                 for (kk in seq_along(NAMES)) {
[01:28:56.671]                   name <- removed[[kk]]
[01:28:56.671]                   NAME <- NAMES[[kk]]
[01:28:56.671]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:56.671]                     next
[01:28:56.671]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:56.671]                 }
[01:28:56.671]                 if (length(args) > 0) 
[01:28:56.671]                   base::do.call(base::Sys.setenv, args = args)
[01:28:56.671]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:56.671]             }
[01:28:56.671]             else {
[01:28:56.671]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:56.671]             }
[01:28:56.671]             {
[01:28:56.671]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:56.671]                   0L) {
[01:28:56.671]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:56.671]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:56.671]                   base::options(opts)
[01:28:56.671]                 }
[01:28:56.671]                 {
[01:28:56.671]                   {
[01:28:56.671]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:56.671]                     NULL
[01:28:56.671]                   }
[01:28:56.671]                   options(future.plan = NULL)
[01:28:56.671]                   if (is.na(NA_character_)) 
[01:28:56.671]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:56.671]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:56.671]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:56.671]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:56.671]                     envir = parent.frame()) 
[01:28:56.671]                   {
[01:28:56.671]                     if (is.function(workers)) 
[01:28:56.671]                       workers <- workers()
[01:28:56.671]                     workers <- structure(as.integer(workers), 
[01:28:56.671]                       class = class(workers))
[01:28:56.671]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:56.671]                       workers >= 1)
[01:28:56.671]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:56.671]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:56.671]                     }
[01:28:56.671]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:56.671]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:56.671]                       envir = envir)
[01:28:56.671]                     if (!future$lazy) 
[01:28:56.671]                       future <- run(future)
[01:28:56.671]                     invisible(future)
[01:28:56.671]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:56.671]                 }
[01:28:56.671]             }
[01:28:56.671]         }
[01:28:56.671]     })
[01:28:56.671]     if (TRUE) {
[01:28:56.671]         base::sink(type = "output", split = FALSE)
[01:28:56.671]         if (TRUE) {
[01:28:56.671]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:56.671]         }
[01:28:56.671]         else {
[01:28:56.671]             ...future.result["stdout"] <- base::list(NULL)
[01:28:56.671]         }
[01:28:56.671]         base::close(...future.stdout)
[01:28:56.671]         ...future.stdout <- NULL
[01:28:56.671]     }
[01:28:56.671]     ...future.result$conditions <- ...future.conditions
[01:28:56.671]     ...future.result$finished <- base::Sys.time()
[01:28:56.671]     ...future.result
[01:28:56.671] }
[01:28:56.678] MultisessionFuture started
[01:28:56.678] - Launch lazy future ... done
[01:28:56.678] run() for 'MultisessionFuture' ... done
[01:28:57.210] receiveMessageFromWorker() for ClusterFuture ...
[01:28:57.211] - Validating connection of MultisessionFuture
[01:28:57.211] - received message: FutureResult
[01:28:57.212] - Received FutureResult
[01:28:57.212] - Erased future from FutureRegistry
[01:28:57.212] result() for ClusterFuture ...
[01:28:57.212] - result already collected: FutureResult
[01:28:57.212] result() for ClusterFuture ... done
[01:28:57.212] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:57.213] A MultisessionFuture was resolved (result was not collected)
- w/ exception ...
[01:28:57.213] getGlobalsAndPackages() ...
[01:28:57.213] Searching for globals...
[01:28:57.214] - globals found: [2] 'list', 'stop'
[01:28:57.215] Searching for globals ... DONE
[01:28:57.215] Resolving globals: FALSE
[01:28:57.215] 
[01:28:57.215] 
[01:28:57.216] getGlobalsAndPackages() ... DONE
[01:28:57.216] run() for 'Future' ...
[01:28:57.216] - state: 'created'
[01:28:57.217] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:57.231] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:57.232] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:57.232]   - Field: 'node'
[01:28:57.232]   - Field: 'label'
[01:28:57.232]   - Field: 'local'
[01:28:57.232]   - Field: 'owner'
[01:28:57.233]   - Field: 'envir'
[01:28:57.233]   - Field: 'workers'
[01:28:57.233]   - Field: 'packages'
[01:28:57.234]   - Field: 'gc'
[01:28:57.234]   - Field: 'conditions'
[01:28:57.234]   - Field: 'persistent'
[01:28:57.235]   - Field: 'expr'
[01:28:57.235]   - Field: 'uuid'
[01:28:57.235]   - Field: 'seed'
[01:28:57.236]   - Field: 'version'
[01:28:57.236]   - Field: 'result'
[01:28:57.236]   - Field: 'asynchronous'
[01:28:57.237]   - Field: 'calls'
[01:28:57.237]   - Field: 'globals'
[01:28:57.238]   - Field: 'stdout'
[01:28:57.238]   - Field: 'earlySignal'
[01:28:57.238]   - Field: 'lazy'
[01:28:57.239]   - Field: 'state'
[01:28:57.239] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:57.239] - Launch lazy future ...
[01:28:57.240] Packages needed by the future expression (n = 0): <none>
[01:28:57.240] Packages needed by future strategies (n = 0): <none>
[01:28:57.242] {
[01:28:57.242]     {
[01:28:57.242]         {
[01:28:57.242]             ...future.startTime <- base::Sys.time()
[01:28:57.242]             {
[01:28:57.242]                 {
[01:28:57.242]                   {
[01:28:57.242]                     {
[01:28:57.242]                       base::local({
[01:28:57.242]                         has_future <- base::requireNamespace("future", 
[01:28:57.242]                           quietly = TRUE)
[01:28:57.242]                         if (has_future) {
[01:28:57.242]                           ns <- base::getNamespace("future")
[01:28:57.242]                           version <- ns[[".package"]][["version"]]
[01:28:57.242]                           if (is.null(version)) 
[01:28:57.242]                             version <- utils::packageVersion("future")
[01:28:57.242]                         }
[01:28:57.242]                         else {
[01:28:57.242]                           version <- NULL
[01:28:57.242]                         }
[01:28:57.242]                         if (!has_future || version < "1.8.0") {
[01:28:57.242]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:57.242]                             "", base::R.version$version.string), 
[01:28:57.242]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:57.242]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:57.242]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:57.242]                               "release", "version")], collapse = " "), 
[01:28:57.242]                             hostname = base::Sys.info()[["nodename"]])
[01:28:57.242]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:57.242]                             info)
[01:28:57.242]                           info <- base::paste(info, collapse = "; ")
[01:28:57.242]                           if (!has_future) {
[01:28:57.242]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:57.242]                               info)
[01:28:57.242]                           }
[01:28:57.242]                           else {
[01:28:57.242]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:57.242]                               info, version)
[01:28:57.242]                           }
[01:28:57.242]                           base::stop(msg)
[01:28:57.242]                         }
[01:28:57.242]                       })
[01:28:57.242]                     }
[01:28:57.242]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:57.242]                     base::options(mc.cores = 1L)
[01:28:57.242]                   }
[01:28:57.242]                   options(future.plan = NULL)
[01:28:57.242]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:57.242]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:57.242]                 }
[01:28:57.242]                 ...future.workdir <- getwd()
[01:28:57.242]             }
[01:28:57.242]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:57.242]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:57.242]         }
[01:28:57.242]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:57.242]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:57.242]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:57.242]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:57.242]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:57.242]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:57.242]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:57.242]             base::names(...future.oldOptions))
[01:28:57.242]     }
[01:28:57.242]     if (FALSE) {
[01:28:57.242]     }
[01:28:57.242]     else {
[01:28:57.242]         if (TRUE) {
[01:28:57.242]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:57.242]                 open = "w")
[01:28:57.242]         }
[01:28:57.242]         else {
[01:28:57.242]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:57.242]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:57.242]         }
[01:28:57.242]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:57.242]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:57.242]             base::sink(type = "output", split = FALSE)
[01:28:57.242]             base::close(...future.stdout)
[01:28:57.242]         }, add = TRUE)
[01:28:57.242]     }
[01:28:57.242]     ...future.frame <- base::sys.nframe()
[01:28:57.242]     ...future.conditions <- base::list()
[01:28:57.242]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:57.242]     if (FALSE) {
[01:28:57.242]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:57.242]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:57.242]     }
[01:28:57.242]     ...future.result <- base::tryCatch({
[01:28:57.242]         base::withCallingHandlers({
[01:28:57.242]             ...future.value <- base::withVisible(base::local({
[01:28:57.242]                 ...future.makeSendCondition <- base::local({
[01:28:57.242]                   sendCondition <- NULL
[01:28:57.242]                   function(frame = 1L) {
[01:28:57.242]                     if (is.function(sendCondition)) 
[01:28:57.242]                       return(sendCondition)
[01:28:57.242]                     ns <- getNamespace("parallel")
[01:28:57.242]                     if (exists("sendData", mode = "function", 
[01:28:57.242]                       envir = ns)) {
[01:28:57.242]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:57.242]                         envir = ns)
[01:28:57.242]                       envir <- sys.frame(frame)
[01:28:57.242]                       master <- NULL
[01:28:57.242]                       while (!identical(envir, .GlobalEnv) && 
[01:28:57.242]                         !identical(envir, emptyenv())) {
[01:28:57.242]                         if (exists("master", mode = "list", envir = envir, 
[01:28:57.242]                           inherits = FALSE)) {
[01:28:57.242]                           master <- get("master", mode = "list", 
[01:28:57.242]                             envir = envir, inherits = FALSE)
[01:28:57.242]                           if (inherits(master, c("SOCKnode", 
[01:28:57.242]                             "SOCK0node"))) {
[01:28:57.242]                             sendCondition <<- function(cond) {
[01:28:57.242]                               data <- list(type = "VALUE", value = cond, 
[01:28:57.242]                                 success = TRUE)
[01:28:57.242]                               parallel_sendData(master, data)
[01:28:57.242]                             }
[01:28:57.242]                             return(sendCondition)
[01:28:57.242]                           }
[01:28:57.242]                         }
[01:28:57.242]                         frame <- frame + 1L
[01:28:57.242]                         envir <- sys.frame(frame)
[01:28:57.242]                       }
[01:28:57.242]                     }
[01:28:57.242]                     sendCondition <<- function(cond) NULL
[01:28:57.242]                   }
[01:28:57.242]                 })
[01:28:57.242]                 withCallingHandlers({
[01:28:57.242]                   list(a = 1, b = 42L, c = stop("Nah!"))
[01:28:57.242]                 }, immediateCondition = function(cond) {
[01:28:57.242]                   sendCondition <- ...future.makeSendCondition()
[01:28:57.242]                   sendCondition(cond)
[01:28:57.242]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:57.242]                   {
[01:28:57.242]                     inherits <- base::inherits
[01:28:57.242]                     invokeRestart <- base::invokeRestart
[01:28:57.242]                     is.null <- base::is.null
[01:28:57.242]                     muffled <- FALSE
[01:28:57.242]                     if (inherits(cond, "message")) {
[01:28:57.242]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:57.242]                       if (muffled) 
[01:28:57.242]                         invokeRestart("muffleMessage")
[01:28:57.242]                     }
[01:28:57.242]                     else if (inherits(cond, "warning")) {
[01:28:57.242]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:57.242]                       if (muffled) 
[01:28:57.242]                         invokeRestart("muffleWarning")
[01:28:57.242]                     }
[01:28:57.242]                     else if (inherits(cond, "condition")) {
[01:28:57.242]                       if (!is.null(pattern)) {
[01:28:57.242]                         computeRestarts <- base::computeRestarts
[01:28:57.242]                         grepl <- base::grepl
[01:28:57.242]                         restarts <- computeRestarts(cond)
[01:28:57.242]                         for (restart in restarts) {
[01:28:57.242]                           name <- restart$name
[01:28:57.242]                           if (is.null(name)) 
[01:28:57.242]                             next
[01:28:57.242]                           if (!grepl(pattern, name)) 
[01:28:57.242]                             next
[01:28:57.242]                           invokeRestart(restart)
[01:28:57.242]                           muffled <- TRUE
[01:28:57.242]                           break
[01:28:57.242]                         }
[01:28:57.242]                       }
[01:28:57.242]                     }
[01:28:57.242]                     invisible(muffled)
[01:28:57.242]                   }
[01:28:57.242]                   muffleCondition(cond)
[01:28:57.242]                 })
[01:28:57.242]             }))
[01:28:57.242]             future::FutureResult(value = ...future.value$value, 
[01:28:57.242]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:57.242]                   ...future.rng), globalenv = if (FALSE) 
[01:28:57.242]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:57.242]                     ...future.globalenv.names))
[01:28:57.242]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:57.242]         }, condition = base::local({
[01:28:57.242]             c <- base::c
[01:28:57.242]             inherits <- base::inherits
[01:28:57.242]             invokeRestart <- base::invokeRestart
[01:28:57.242]             length <- base::length
[01:28:57.242]             list <- base::list
[01:28:57.242]             seq.int <- base::seq.int
[01:28:57.242]             signalCondition <- base::signalCondition
[01:28:57.242]             sys.calls <- base::sys.calls
[01:28:57.242]             `[[` <- base::`[[`
[01:28:57.242]             `+` <- base::`+`
[01:28:57.242]             `<<-` <- base::`<<-`
[01:28:57.242]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:57.242]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:57.242]                   3L)]
[01:28:57.242]             }
[01:28:57.242]             function(cond) {
[01:28:57.242]                 is_error <- inherits(cond, "error")
[01:28:57.242]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:57.242]                   NULL)
[01:28:57.242]                 if (is_error) {
[01:28:57.242]                   sessionInformation <- function() {
[01:28:57.242]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:57.242]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:57.242]                       search = base::search(), system = base::Sys.info())
[01:28:57.242]                   }
[01:28:57.242]                   ...future.conditions[[length(...future.conditions) + 
[01:28:57.242]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:57.242]                     cond$call), session = sessionInformation(), 
[01:28:57.242]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:57.242]                   signalCondition(cond)
[01:28:57.242]                 }
[01:28:57.242]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:57.242]                 "immediateCondition"))) {
[01:28:57.242]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:57.242]                   ...future.conditions[[length(...future.conditions) + 
[01:28:57.242]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:57.242]                   if (TRUE && !signal) {
[01:28:57.242]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:57.242]                     {
[01:28:57.242]                       inherits <- base::inherits
[01:28:57.242]                       invokeRestart <- base::invokeRestart
[01:28:57.242]                       is.null <- base::is.null
[01:28:57.242]                       muffled <- FALSE
[01:28:57.242]                       if (inherits(cond, "message")) {
[01:28:57.242]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:57.242]                         if (muffled) 
[01:28:57.242]                           invokeRestart("muffleMessage")
[01:28:57.242]                       }
[01:28:57.242]                       else if (inherits(cond, "warning")) {
[01:28:57.242]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:57.242]                         if (muffled) 
[01:28:57.242]                           invokeRestart("muffleWarning")
[01:28:57.242]                       }
[01:28:57.242]                       else if (inherits(cond, "condition")) {
[01:28:57.242]                         if (!is.null(pattern)) {
[01:28:57.242]                           computeRestarts <- base::computeRestarts
[01:28:57.242]                           grepl <- base::grepl
[01:28:57.242]                           restarts <- computeRestarts(cond)
[01:28:57.242]                           for (restart in restarts) {
[01:28:57.242]                             name <- restart$name
[01:28:57.242]                             if (is.null(name)) 
[01:28:57.242]                               next
[01:28:57.242]                             if (!grepl(pattern, name)) 
[01:28:57.242]                               next
[01:28:57.242]                             invokeRestart(restart)
[01:28:57.242]                             muffled <- TRUE
[01:28:57.242]                             break
[01:28:57.242]                           }
[01:28:57.242]                         }
[01:28:57.242]                       }
[01:28:57.242]                       invisible(muffled)
[01:28:57.242]                     }
[01:28:57.242]                     muffleCondition(cond, pattern = "^muffle")
[01:28:57.242]                   }
[01:28:57.242]                 }
[01:28:57.242]                 else {
[01:28:57.242]                   if (TRUE) {
[01:28:57.242]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:57.242]                     {
[01:28:57.242]                       inherits <- base::inherits
[01:28:57.242]                       invokeRestart <- base::invokeRestart
[01:28:57.242]                       is.null <- base::is.null
[01:28:57.242]                       muffled <- FALSE
[01:28:57.242]                       if (inherits(cond, "message")) {
[01:28:57.242]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:57.242]                         if (muffled) 
[01:28:57.242]                           invokeRestart("muffleMessage")
[01:28:57.242]                       }
[01:28:57.242]                       else if (inherits(cond, "warning")) {
[01:28:57.242]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:57.242]                         if (muffled) 
[01:28:57.242]                           invokeRestart("muffleWarning")
[01:28:57.242]                       }
[01:28:57.242]                       else if (inherits(cond, "condition")) {
[01:28:57.242]                         if (!is.null(pattern)) {
[01:28:57.242]                           computeRestarts <- base::computeRestarts
[01:28:57.242]                           grepl <- base::grepl
[01:28:57.242]                           restarts <- computeRestarts(cond)
[01:28:57.242]                           for (restart in restarts) {
[01:28:57.242]                             name <- restart$name
[01:28:57.242]                             if (is.null(name)) 
[01:28:57.242]                               next
[01:28:57.242]                             if (!grepl(pattern, name)) 
[01:28:57.242]                               next
[01:28:57.242]                             invokeRestart(restart)
[01:28:57.242]                             muffled <- TRUE
[01:28:57.242]                             break
[01:28:57.242]                           }
[01:28:57.242]                         }
[01:28:57.242]                       }
[01:28:57.242]                       invisible(muffled)
[01:28:57.242]                     }
[01:28:57.242]                     muffleCondition(cond, pattern = "^muffle")
[01:28:57.242]                   }
[01:28:57.242]                 }
[01:28:57.242]             }
[01:28:57.242]         }))
[01:28:57.242]     }, error = function(ex) {
[01:28:57.242]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:57.242]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:57.242]                 ...future.rng), started = ...future.startTime, 
[01:28:57.242]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:57.242]             version = "1.8"), class = "FutureResult")
[01:28:57.242]     }, finally = {
[01:28:57.242]         if (!identical(...future.workdir, getwd())) 
[01:28:57.242]             setwd(...future.workdir)
[01:28:57.242]         {
[01:28:57.242]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:57.242]                 ...future.oldOptions$nwarnings <- NULL
[01:28:57.242]             }
[01:28:57.242]             base::options(...future.oldOptions)
[01:28:57.242]             if (.Platform$OS.type == "windows") {
[01:28:57.242]                 old_names <- names(...future.oldEnvVars)
[01:28:57.242]                 envs <- base::Sys.getenv()
[01:28:57.242]                 names <- names(envs)
[01:28:57.242]                 common <- intersect(names, old_names)
[01:28:57.242]                 added <- setdiff(names, old_names)
[01:28:57.242]                 removed <- setdiff(old_names, names)
[01:28:57.242]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:57.242]                   envs[common]]
[01:28:57.242]                 NAMES <- toupper(changed)
[01:28:57.242]                 args <- list()
[01:28:57.242]                 for (kk in seq_along(NAMES)) {
[01:28:57.242]                   name <- changed[[kk]]
[01:28:57.242]                   NAME <- NAMES[[kk]]
[01:28:57.242]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:57.242]                     next
[01:28:57.242]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:57.242]                 }
[01:28:57.242]                 NAMES <- toupper(added)
[01:28:57.242]                 for (kk in seq_along(NAMES)) {
[01:28:57.242]                   name <- added[[kk]]
[01:28:57.242]                   NAME <- NAMES[[kk]]
[01:28:57.242]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:57.242]                     next
[01:28:57.242]                   args[[name]] <- ""
[01:28:57.242]                 }
[01:28:57.242]                 NAMES <- toupper(removed)
[01:28:57.242]                 for (kk in seq_along(NAMES)) {
[01:28:57.242]                   name <- removed[[kk]]
[01:28:57.242]                   NAME <- NAMES[[kk]]
[01:28:57.242]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:57.242]                     next
[01:28:57.242]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:57.242]                 }
[01:28:57.242]                 if (length(args) > 0) 
[01:28:57.242]                   base::do.call(base::Sys.setenv, args = args)
[01:28:57.242]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:57.242]             }
[01:28:57.242]             else {
[01:28:57.242]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:57.242]             }
[01:28:57.242]             {
[01:28:57.242]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:57.242]                   0L) {
[01:28:57.242]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:57.242]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:57.242]                   base::options(opts)
[01:28:57.242]                 }
[01:28:57.242]                 {
[01:28:57.242]                   {
[01:28:57.242]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:57.242]                     NULL
[01:28:57.242]                   }
[01:28:57.242]                   options(future.plan = NULL)
[01:28:57.242]                   if (is.na(NA_character_)) 
[01:28:57.242]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:57.242]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:57.242]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:57.242]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:57.242]                     envir = parent.frame()) 
[01:28:57.242]                   {
[01:28:57.242]                     if (is.function(workers)) 
[01:28:57.242]                       workers <- workers()
[01:28:57.242]                     workers <- structure(as.integer(workers), 
[01:28:57.242]                       class = class(workers))
[01:28:57.242]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:57.242]                       workers >= 1)
[01:28:57.242]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:57.242]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:57.242]                     }
[01:28:57.242]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:57.242]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:57.242]                       envir = envir)
[01:28:57.242]                     if (!future$lazy) 
[01:28:57.242]                       future <- run(future)
[01:28:57.242]                     invisible(future)
[01:28:57.242]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:57.242]                 }
[01:28:57.242]             }
[01:28:57.242]         }
[01:28:57.242]     })
[01:28:57.242]     if (TRUE) {
[01:28:57.242]         base::sink(type = "output", split = FALSE)
[01:28:57.242]         if (TRUE) {
[01:28:57.242]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:57.242]         }
[01:28:57.242]         else {
[01:28:57.242]             ...future.result["stdout"] <- base::list(NULL)
[01:28:57.242]         }
[01:28:57.242]         base::close(...future.stdout)
[01:28:57.242]         ...future.stdout <- NULL
[01:28:57.242]     }
[01:28:57.242]     ...future.result$conditions <- ...future.conditions
[01:28:57.242]     ...future.result$finished <- base::Sys.time()
[01:28:57.242]     ...future.result
[01:28:57.242] }
[01:28:57.252] MultisessionFuture started
[01:28:57.252] - Launch lazy future ... done
[01:28:57.252] run() for 'MultisessionFuture' ... done
[01:28:57.277] receiveMessageFromWorker() for ClusterFuture ...
[01:28:57.277] - Validating connection of MultisessionFuture
[01:28:57.278] - received message: FutureResult
[01:28:57.278] - Received FutureResult
[01:28:57.278] - Erased future from FutureRegistry
[01:28:57.279] result() for ClusterFuture ...
[01:28:57.279] - result already collected: FutureResult
[01:28:57.279] result() for ClusterFuture ... done
[01:28:57.279] signalConditions() ...
[01:28:57.279]  - include = 'immediateCondition'
[01:28:57.280]  - exclude = 
[01:28:57.280]  - resignal = FALSE
[01:28:57.280]  - Number of conditions: 1
[01:28:57.280] signalConditions() ... done
[01:28:57.280] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:57.281] A MultisessionFuture was resolved (result was not collected)
[01:28:57.281] getGlobalsAndPackages() ...
[01:28:57.281] Searching for globals...
[01:28:57.282] - globals found: [2] 'list', 'stop'
[01:28:57.282] Searching for globals ... DONE
[01:28:57.282] Resolving globals: FALSE
[01:28:57.283] 
[01:28:57.283] 
[01:28:57.283] getGlobalsAndPackages() ... DONE
[01:28:57.284] run() for 'Future' ...
[01:28:57.284] - state: 'created'
[01:28:57.284] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:57.301] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:57.301] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:57.302]   - Field: 'node'
[01:28:57.302]   - Field: 'label'
[01:28:57.302]   - Field: 'local'
[01:28:57.302]   - Field: 'owner'
[01:28:57.302]   - Field: 'envir'
[01:28:57.303]   - Field: 'workers'
[01:28:57.303]   - Field: 'packages'
[01:28:57.303]   - Field: 'gc'
[01:28:57.303]   - Field: 'conditions'
[01:28:57.303]   - Field: 'persistent'
[01:28:57.303]   - Field: 'expr'
[01:28:57.304]   - Field: 'uuid'
[01:28:57.304]   - Field: 'seed'
[01:28:57.304]   - Field: 'version'
[01:28:57.304]   - Field: 'result'
[01:28:57.304]   - Field: 'asynchronous'
[01:28:57.305]   - Field: 'calls'
[01:28:57.305]   - Field: 'globals'
[01:28:57.305]   - Field: 'stdout'
[01:28:57.305]   - Field: 'earlySignal'
[01:28:57.305]   - Field: 'lazy'
[01:28:57.305]   - Field: 'state'
[01:28:57.306] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:57.306] - Launch lazy future ...
[01:28:57.306] Packages needed by the future expression (n = 0): <none>
[01:28:57.306] Packages needed by future strategies (n = 0): <none>
[01:28:57.307] {
[01:28:57.307]     {
[01:28:57.307]         {
[01:28:57.307]             ...future.startTime <- base::Sys.time()
[01:28:57.307]             {
[01:28:57.307]                 {
[01:28:57.307]                   {
[01:28:57.307]                     {
[01:28:57.307]                       base::local({
[01:28:57.307]                         has_future <- base::requireNamespace("future", 
[01:28:57.307]                           quietly = TRUE)
[01:28:57.307]                         if (has_future) {
[01:28:57.307]                           ns <- base::getNamespace("future")
[01:28:57.307]                           version <- ns[[".package"]][["version"]]
[01:28:57.307]                           if (is.null(version)) 
[01:28:57.307]                             version <- utils::packageVersion("future")
[01:28:57.307]                         }
[01:28:57.307]                         else {
[01:28:57.307]                           version <- NULL
[01:28:57.307]                         }
[01:28:57.307]                         if (!has_future || version < "1.8.0") {
[01:28:57.307]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:57.307]                             "", base::R.version$version.string), 
[01:28:57.307]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:57.307]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:57.307]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:57.307]                               "release", "version")], collapse = " "), 
[01:28:57.307]                             hostname = base::Sys.info()[["nodename"]])
[01:28:57.307]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:57.307]                             info)
[01:28:57.307]                           info <- base::paste(info, collapse = "; ")
[01:28:57.307]                           if (!has_future) {
[01:28:57.307]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:57.307]                               info)
[01:28:57.307]                           }
[01:28:57.307]                           else {
[01:28:57.307]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:57.307]                               info, version)
[01:28:57.307]                           }
[01:28:57.307]                           base::stop(msg)
[01:28:57.307]                         }
[01:28:57.307]                       })
[01:28:57.307]                     }
[01:28:57.307]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:57.307]                     base::options(mc.cores = 1L)
[01:28:57.307]                   }
[01:28:57.307]                   options(future.plan = NULL)
[01:28:57.307]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:57.307]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:57.307]                 }
[01:28:57.307]                 ...future.workdir <- getwd()
[01:28:57.307]             }
[01:28:57.307]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:57.307]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:57.307]         }
[01:28:57.307]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:57.307]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:57.307]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:57.307]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:57.307]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:57.307]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:57.307]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:57.307]             base::names(...future.oldOptions))
[01:28:57.307]     }
[01:28:57.307]     if (FALSE) {
[01:28:57.307]     }
[01:28:57.307]     else {
[01:28:57.307]         if (TRUE) {
[01:28:57.307]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:57.307]                 open = "w")
[01:28:57.307]         }
[01:28:57.307]         else {
[01:28:57.307]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:57.307]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:57.307]         }
[01:28:57.307]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:57.307]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:57.307]             base::sink(type = "output", split = FALSE)
[01:28:57.307]             base::close(...future.stdout)
[01:28:57.307]         }, add = TRUE)
[01:28:57.307]     }
[01:28:57.307]     ...future.frame <- base::sys.nframe()
[01:28:57.307]     ...future.conditions <- base::list()
[01:28:57.307]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:57.307]     if (FALSE) {
[01:28:57.307]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:57.307]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:57.307]     }
[01:28:57.307]     ...future.result <- base::tryCatch({
[01:28:57.307]         base::withCallingHandlers({
[01:28:57.307]             ...future.value <- base::withVisible(base::local({
[01:28:57.307]                 ...future.makeSendCondition <- base::local({
[01:28:57.307]                   sendCondition <- NULL
[01:28:57.307]                   function(frame = 1L) {
[01:28:57.307]                     if (is.function(sendCondition)) 
[01:28:57.307]                       return(sendCondition)
[01:28:57.307]                     ns <- getNamespace("parallel")
[01:28:57.307]                     if (exists("sendData", mode = "function", 
[01:28:57.307]                       envir = ns)) {
[01:28:57.307]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:57.307]                         envir = ns)
[01:28:57.307]                       envir <- sys.frame(frame)
[01:28:57.307]                       master <- NULL
[01:28:57.307]                       while (!identical(envir, .GlobalEnv) && 
[01:28:57.307]                         !identical(envir, emptyenv())) {
[01:28:57.307]                         if (exists("master", mode = "list", envir = envir, 
[01:28:57.307]                           inherits = FALSE)) {
[01:28:57.307]                           master <- get("master", mode = "list", 
[01:28:57.307]                             envir = envir, inherits = FALSE)
[01:28:57.307]                           if (inherits(master, c("SOCKnode", 
[01:28:57.307]                             "SOCK0node"))) {
[01:28:57.307]                             sendCondition <<- function(cond) {
[01:28:57.307]                               data <- list(type = "VALUE", value = cond, 
[01:28:57.307]                                 success = TRUE)
[01:28:57.307]                               parallel_sendData(master, data)
[01:28:57.307]                             }
[01:28:57.307]                             return(sendCondition)
[01:28:57.307]                           }
[01:28:57.307]                         }
[01:28:57.307]                         frame <- frame + 1L
[01:28:57.307]                         envir <- sys.frame(frame)
[01:28:57.307]                       }
[01:28:57.307]                     }
[01:28:57.307]                     sendCondition <<- function(cond) NULL
[01:28:57.307]                   }
[01:28:57.307]                 })
[01:28:57.307]                 withCallingHandlers({
[01:28:57.307]                   list(a = 1, b = 42L, c = stop("Nah!"))
[01:28:57.307]                 }, immediateCondition = function(cond) {
[01:28:57.307]                   sendCondition <- ...future.makeSendCondition()
[01:28:57.307]                   sendCondition(cond)
[01:28:57.307]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:57.307]                   {
[01:28:57.307]                     inherits <- base::inherits
[01:28:57.307]                     invokeRestart <- base::invokeRestart
[01:28:57.307]                     is.null <- base::is.null
[01:28:57.307]                     muffled <- FALSE
[01:28:57.307]                     if (inherits(cond, "message")) {
[01:28:57.307]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:57.307]                       if (muffled) 
[01:28:57.307]                         invokeRestart("muffleMessage")
[01:28:57.307]                     }
[01:28:57.307]                     else if (inherits(cond, "warning")) {
[01:28:57.307]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:57.307]                       if (muffled) 
[01:28:57.307]                         invokeRestart("muffleWarning")
[01:28:57.307]                     }
[01:28:57.307]                     else if (inherits(cond, "condition")) {
[01:28:57.307]                       if (!is.null(pattern)) {
[01:28:57.307]                         computeRestarts <- base::computeRestarts
[01:28:57.307]                         grepl <- base::grepl
[01:28:57.307]                         restarts <- computeRestarts(cond)
[01:28:57.307]                         for (restart in restarts) {
[01:28:57.307]                           name <- restart$name
[01:28:57.307]                           if (is.null(name)) 
[01:28:57.307]                             next
[01:28:57.307]                           if (!grepl(pattern, name)) 
[01:28:57.307]                             next
[01:28:57.307]                           invokeRestart(restart)
[01:28:57.307]                           muffled <- TRUE
[01:28:57.307]                           break
[01:28:57.307]                         }
[01:28:57.307]                       }
[01:28:57.307]                     }
[01:28:57.307]                     invisible(muffled)
[01:28:57.307]                   }
[01:28:57.307]                   muffleCondition(cond)
[01:28:57.307]                 })
[01:28:57.307]             }))
[01:28:57.307]             future::FutureResult(value = ...future.value$value, 
[01:28:57.307]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:57.307]                   ...future.rng), globalenv = if (FALSE) 
[01:28:57.307]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:57.307]                     ...future.globalenv.names))
[01:28:57.307]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:57.307]         }, condition = base::local({
[01:28:57.307]             c <- base::c
[01:28:57.307]             inherits <- base::inherits
[01:28:57.307]             invokeRestart <- base::invokeRestart
[01:28:57.307]             length <- base::length
[01:28:57.307]             list <- base::list
[01:28:57.307]             seq.int <- base::seq.int
[01:28:57.307]             signalCondition <- base::signalCondition
[01:28:57.307]             sys.calls <- base::sys.calls
[01:28:57.307]             `[[` <- base::`[[`
[01:28:57.307]             `+` <- base::`+`
[01:28:57.307]             `<<-` <- base::`<<-`
[01:28:57.307]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:57.307]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:57.307]                   3L)]
[01:28:57.307]             }
[01:28:57.307]             function(cond) {
[01:28:57.307]                 is_error <- inherits(cond, "error")
[01:28:57.307]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:57.307]                   NULL)
[01:28:57.307]                 if (is_error) {
[01:28:57.307]                   sessionInformation <- function() {
[01:28:57.307]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:57.307]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:57.307]                       search = base::search(), system = base::Sys.info())
[01:28:57.307]                   }
[01:28:57.307]                   ...future.conditions[[length(...future.conditions) + 
[01:28:57.307]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:57.307]                     cond$call), session = sessionInformation(), 
[01:28:57.307]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:57.307]                   signalCondition(cond)
[01:28:57.307]                 }
[01:28:57.307]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:57.307]                 "immediateCondition"))) {
[01:28:57.307]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:57.307]                   ...future.conditions[[length(...future.conditions) + 
[01:28:57.307]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:57.307]                   if (TRUE && !signal) {
[01:28:57.307]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:57.307]                     {
[01:28:57.307]                       inherits <- base::inherits
[01:28:57.307]                       invokeRestart <- base::invokeRestart
[01:28:57.307]                       is.null <- base::is.null
[01:28:57.307]                       muffled <- FALSE
[01:28:57.307]                       if (inherits(cond, "message")) {
[01:28:57.307]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:57.307]                         if (muffled) 
[01:28:57.307]                           invokeRestart("muffleMessage")
[01:28:57.307]                       }
[01:28:57.307]                       else if (inherits(cond, "warning")) {
[01:28:57.307]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:57.307]                         if (muffled) 
[01:28:57.307]                           invokeRestart("muffleWarning")
[01:28:57.307]                       }
[01:28:57.307]                       else if (inherits(cond, "condition")) {
[01:28:57.307]                         if (!is.null(pattern)) {
[01:28:57.307]                           computeRestarts <- base::computeRestarts
[01:28:57.307]                           grepl <- base::grepl
[01:28:57.307]                           restarts <- computeRestarts(cond)
[01:28:57.307]                           for (restart in restarts) {
[01:28:57.307]                             name <- restart$name
[01:28:57.307]                             if (is.null(name)) 
[01:28:57.307]                               next
[01:28:57.307]                             if (!grepl(pattern, name)) 
[01:28:57.307]                               next
[01:28:57.307]                             invokeRestart(restart)
[01:28:57.307]                             muffled <- TRUE
[01:28:57.307]                             break
[01:28:57.307]                           }
[01:28:57.307]                         }
[01:28:57.307]                       }
[01:28:57.307]                       invisible(muffled)
[01:28:57.307]                     }
[01:28:57.307]                     muffleCondition(cond, pattern = "^muffle")
[01:28:57.307]                   }
[01:28:57.307]                 }
[01:28:57.307]                 else {
[01:28:57.307]                   if (TRUE) {
[01:28:57.307]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:57.307]                     {
[01:28:57.307]                       inherits <- base::inherits
[01:28:57.307]                       invokeRestart <- base::invokeRestart
[01:28:57.307]                       is.null <- base::is.null
[01:28:57.307]                       muffled <- FALSE
[01:28:57.307]                       if (inherits(cond, "message")) {
[01:28:57.307]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:57.307]                         if (muffled) 
[01:28:57.307]                           invokeRestart("muffleMessage")
[01:28:57.307]                       }
[01:28:57.307]                       else if (inherits(cond, "warning")) {
[01:28:57.307]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:57.307]                         if (muffled) 
[01:28:57.307]                           invokeRestart("muffleWarning")
[01:28:57.307]                       }
[01:28:57.307]                       else if (inherits(cond, "condition")) {
[01:28:57.307]                         if (!is.null(pattern)) {
[01:28:57.307]                           computeRestarts <- base::computeRestarts
[01:28:57.307]                           grepl <- base::grepl
[01:28:57.307]                           restarts <- computeRestarts(cond)
[01:28:57.307]                           for (restart in restarts) {
[01:28:57.307]                             name <- restart$name
[01:28:57.307]                             if (is.null(name)) 
[01:28:57.307]                               next
[01:28:57.307]                             if (!grepl(pattern, name)) 
[01:28:57.307]                               next
[01:28:57.307]                             invokeRestart(restart)
[01:28:57.307]                             muffled <- TRUE
[01:28:57.307]                             break
[01:28:57.307]                           }
[01:28:57.307]                         }
[01:28:57.307]                       }
[01:28:57.307]                       invisible(muffled)
[01:28:57.307]                     }
[01:28:57.307]                     muffleCondition(cond, pattern = "^muffle")
[01:28:57.307]                   }
[01:28:57.307]                 }
[01:28:57.307]             }
[01:28:57.307]         }))
[01:28:57.307]     }, error = function(ex) {
[01:28:57.307]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:57.307]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:57.307]                 ...future.rng), started = ...future.startTime, 
[01:28:57.307]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:57.307]             version = "1.8"), class = "FutureResult")
[01:28:57.307]     }, finally = {
[01:28:57.307]         if (!identical(...future.workdir, getwd())) 
[01:28:57.307]             setwd(...future.workdir)
[01:28:57.307]         {
[01:28:57.307]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:57.307]                 ...future.oldOptions$nwarnings <- NULL
[01:28:57.307]             }
[01:28:57.307]             base::options(...future.oldOptions)
[01:28:57.307]             if (.Platform$OS.type == "windows") {
[01:28:57.307]                 old_names <- names(...future.oldEnvVars)
[01:28:57.307]                 envs <- base::Sys.getenv()
[01:28:57.307]                 names <- names(envs)
[01:28:57.307]                 common <- intersect(names, old_names)
[01:28:57.307]                 added <- setdiff(names, old_names)
[01:28:57.307]                 removed <- setdiff(old_names, names)
[01:28:57.307]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:57.307]                   envs[common]]
[01:28:57.307]                 NAMES <- toupper(changed)
[01:28:57.307]                 args <- list()
[01:28:57.307]                 for (kk in seq_along(NAMES)) {
[01:28:57.307]                   name <- changed[[kk]]
[01:28:57.307]                   NAME <- NAMES[[kk]]
[01:28:57.307]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:57.307]                     next
[01:28:57.307]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:57.307]                 }
[01:28:57.307]                 NAMES <- toupper(added)
[01:28:57.307]                 for (kk in seq_along(NAMES)) {
[01:28:57.307]                   name <- added[[kk]]
[01:28:57.307]                   NAME <- NAMES[[kk]]
[01:28:57.307]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:57.307]                     next
[01:28:57.307]                   args[[name]] <- ""
[01:28:57.307]                 }
[01:28:57.307]                 NAMES <- toupper(removed)
[01:28:57.307]                 for (kk in seq_along(NAMES)) {
[01:28:57.307]                   name <- removed[[kk]]
[01:28:57.307]                   NAME <- NAMES[[kk]]
[01:28:57.307]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:57.307]                     next
[01:28:57.307]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:57.307]                 }
[01:28:57.307]                 if (length(args) > 0) 
[01:28:57.307]                   base::do.call(base::Sys.setenv, args = args)
[01:28:57.307]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:57.307]             }
[01:28:57.307]             else {
[01:28:57.307]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:57.307]             }
[01:28:57.307]             {
[01:28:57.307]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:57.307]                   0L) {
[01:28:57.307]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:57.307]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:57.307]                   base::options(opts)
[01:28:57.307]                 }
[01:28:57.307]                 {
[01:28:57.307]                   {
[01:28:57.307]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:57.307]                     NULL
[01:28:57.307]                   }
[01:28:57.307]                   options(future.plan = NULL)
[01:28:57.307]                   if (is.na(NA_character_)) 
[01:28:57.307]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:57.307]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:57.307]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:57.307]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:57.307]                     envir = parent.frame()) 
[01:28:57.307]                   {
[01:28:57.307]                     if (is.function(workers)) 
[01:28:57.307]                       workers <- workers()
[01:28:57.307]                     workers <- structure(as.integer(workers), 
[01:28:57.307]                       class = class(workers))
[01:28:57.307]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:57.307]                       workers >= 1)
[01:28:57.307]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:57.307]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:57.307]                     }
[01:28:57.307]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:57.307]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:57.307]                       envir = envir)
[01:28:57.307]                     if (!future$lazy) 
[01:28:57.307]                       future <- run(future)
[01:28:57.307]                     invisible(future)
[01:28:57.307]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:57.307]                 }
[01:28:57.307]             }
[01:28:57.307]         }
[01:28:57.307]     })
[01:28:57.307]     if (TRUE) {
[01:28:57.307]         base::sink(type = "output", split = FALSE)
[01:28:57.307]         if (TRUE) {
[01:28:57.307]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:57.307]         }
[01:28:57.307]         else {
[01:28:57.307]             ...future.result["stdout"] <- base::list(NULL)
[01:28:57.307]         }
[01:28:57.307]         base::close(...future.stdout)
[01:28:57.307]         ...future.stdout <- NULL
[01:28:57.307]     }
[01:28:57.307]     ...future.result$conditions <- ...future.conditions
[01:28:57.307]     ...future.result$finished <- base::Sys.time()
[01:28:57.307]     ...future.result
[01:28:57.307] }
[01:28:57.313] MultisessionFuture started
[01:28:57.313] - Launch lazy future ... done
[01:28:57.313] run() for 'MultisessionFuture' ... done
[01:28:57.343] receiveMessageFromWorker() for ClusterFuture ...
[01:28:57.343] - Validating connection of MultisessionFuture
[01:28:57.344] - received message: FutureResult
[01:28:57.344] - Received FutureResult
[01:28:57.345] - Erased future from FutureRegistry
[01:28:57.345] result() for ClusterFuture ...
[01:28:57.345] - result already collected: FutureResult
[01:28:57.345] result() for ClusterFuture ... done
[01:28:57.345] signalConditions() ...
[01:28:57.345]  - include = 'immediateCondition'
[01:28:57.346]  - exclude = 
[01:28:57.346]  - resignal = FALSE
[01:28:57.346]  - Number of conditions: 1
[01:28:57.346] signalConditions() ... done
[01:28:57.346] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:57.346] A MultisessionFuture was resolved (result was not collected)
- result = FALSE, recursive = FALSE ... DONE
- result = FALSE, recursive = TRUE ...
[01:28:57.347] getGlobalsAndPackages() ...
[01:28:57.347] Searching for globals...
[01:28:57.348] - globals found: [3] '{', 'Sys.sleep', 'list'
[01:28:57.349] Searching for globals ... DONE
[01:28:57.349] Resolving globals: FALSE
[01:28:57.349] 
[01:28:57.349] 
[01:28:57.350] getGlobalsAndPackages() ... DONE
[01:28:57.350] run() for 'Future' ...
[01:28:57.350] - state: 'created'
[01:28:57.350] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:57.366] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:57.366] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:57.366]   - Field: 'node'
[01:28:57.366]   - Field: 'label'
[01:28:57.366]   - Field: 'local'
[01:28:57.367]   - Field: 'owner'
[01:28:57.367]   - Field: 'envir'
[01:28:57.367]   - Field: 'workers'
[01:28:57.367]   - Field: 'packages'
[01:28:57.367]   - Field: 'gc'
[01:28:57.368]   - Field: 'conditions'
[01:28:57.368]   - Field: 'persistent'
[01:28:57.368]   - Field: 'expr'
[01:28:57.368]   - Field: 'uuid'
[01:28:57.368]   - Field: 'seed'
[01:28:57.368]   - Field: 'version'
[01:28:57.369]   - Field: 'result'
[01:28:57.369]   - Field: 'asynchronous'
[01:28:57.369]   - Field: 'calls'
[01:28:57.369]   - Field: 'globals'
[01:28:57.369]   - Field: 'stdout'
[01:28:57.370]   - Field: 'earlySignal'
[01:28:57.370]   - Field: 'lazy'
[01:28:57.370]   - Field: 'state'
[01:28:57.370] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:57.370] - Launch lazy future ...
[01:28:57.371] Packages needed by the future expression (n = 0): <none>
[01:28:57.371] Packages needed by future strategies (n = 0): <none>
[01:28:57.371] {
[01:28:57.371]     {
[01:28:57.371]         {
[01:28:57.371]             ...future.startTime <- base::Sys.time()
[01:28:57.371]             {
[01:28:57.371]                 {
[01:28:57.371]                   {
[01:28:57.371]                     {
[01:28:57.371]                       base::local({
[01:28:57.371]                         has_future <- base::requireNamespace("future", 
[01:28:57.371]                           quietly = TRUE)
[01:28:57.371]                         if (has_future) {
[01:28:57.371]                           ns <- base::getNamespace("future")
[01:28:57.371]                           version <- ns[[".package"]][["version"]]
[01:28:57.371]                           if (is.null(version)) 
[01:28:57.371]                             version <- utils::packageVersion("future")
[01:28:57.371]                         }
[01:28:57.371]                         else {
[01:28:57.371]                           version <- NULL
[01:28:57.371]                         }
[01:28:57.371]                         if (!has_future || version < "1.8.0") {
[01:28:57.371]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:57.371]                             "", base::R.version$version.string), 
[01:28:57.371]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:57.371]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:57.371]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:57.371]                               "release", "version")], collapse = " "), 
[01:28:57.371]                             hostname = base::Sys.info()[["nodename"]])
[01:28:57.371]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:57.371]                             info)
[01:28:57.371]                           info <- base::paste(info, collapse = "; ")
[01:28:57.371]                           if (!has_future) {
[01:28:57.371]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:57.371]                               info)
[01:28:57.371]                           }
[01:28:57.371]                           else {
[01:28:57.371]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:57.371]                               info, version)
[01:28:57.371]                           }
[01:28:57.371]                           base::stop(msg)
[01:28:57.371]                         }
[01:28:57.371]                       })
[01:28:57.371]                     }
[01:28:57.371]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:57.371]                     base::options(mc.cores = 1L)
[01:28:57.371]                   }
[01:28:57.371]                   options(future.plan = NULL)
[01:28:57.371]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:57.371]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:57.371]                 }
[01:28:57.371]                 ...future.workdir <- getwd()
[01:28:57.371]             }
[01:28:57.371]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:57.371]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:57.371]         }
[01:28:57.371]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:57.371]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:57.371]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:57.371]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:57.371]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:57.371]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:57.371]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:57.371]             base::names(...future.oldOptions))
[01:28:57.371]     }
[01:28:57.371]     if (FALSE) {
[01:28:57.371]     }
[01:28:57.371]     else {
[01:28:57.371]         if (TRUE) {
[01:28:57.371]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:57.371]                 open = "w")
[01:28:57.371]         }
[01:28:57.371]         else {
[01:28:57.371]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:57.371]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:57.371]         }
[01:28:57.371]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:57.371]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:57.371]             base::sink(type = "output", split = FALSE)
[01:28:57.371]             base::close(...future.stdout)
[01:28:57.371]         }, add = TRUE)
[01:28:57.371]     }
[01:28:57.371]     ...future.frame <- base::sys.nframe()
[01:28:57.371]     ...future.conditions <- base::list()
[01:28:57.371]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:57.371]     if (FALSE) {
[01:28:57.371]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:57.371]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:57.371]     }
[01:28:57.371]     ...future.result <- base::tryCatch({
[01:28:57.371]         base::withCallingHandlers({
[01:28:57.371]             ...future.value <- base::withVisible(base::local({
[01:28:57.371]                 ...future.makeSendCondition <- base::local({
[01:28:57.371]                   sendCondition <- NULL
[01:28:57.371]                   function(frame = 1L) {
[01:28:57.371]                     if (is.function(sendCondition)) 
[01:28:57.371]                       return(sendCondition)
[01:28:57.371]                     ns <- getNamespace("parallel")
[01:28:57.371]                     if (exists("sendData", mode = "function", 
[01:28:57.371]                       envir = ns)) {
[01:28:57.371]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:57.371]                         envir = ns)
[01:28:57.371]                       envir <- sys.frame(frame)
[01:28:57.371]                       master <- NULL
[01:28:57.371]                       while (!identical(envir, .GlobalEnv) && 
[01:28:57.371]                         !identical(envir, emptyenv())) {
[01:28:57.371]                         if (exists("master", mode = "list", envir = envir, 
[01:28:57.371]                           inherits = FALSE)) {
[01:28:57.371]                           master <- get("master", mode = "list", 
[01:28:57.371]                             envir = envir, inherits = FALSE)
[01:28:57.371]                           if (inherits(master, c("SOCKnode", 
[01:28:57.371]                             "SOCK0node"))) {
[01:28:57.371]                             sendCondition <<- function(cond) {
[01:28:57.371]                               data <- list(type = "VALUE", value = cond, 
[01:28:57.371]                                 success = TRUE)
[01:28:57.371]                               parallel_sendData(master, data)
[01:28:57.371]                             }
[01:28:57.371]                             return(sendCondition)
[01:28:57.371]                           }
[01:28:57.371]                         }
[01:28:57.371]                         frame <- frame + 1L
[01:28:57.371]                         envir <- sys.frame(frame)
[01:28:57.371]                       }
[01:28:57.371]                     }
[01:28:57.371]                     sendCondition <<- function(cond) NULL
[01:28:57.371]                   }
[01:28:57.371]                 })
[01:28:57.371]                 withCallingHandlers({
[01:28:57.371]                   {
[01:28:57.371]                     Sys.sleep(0.5)
[01:28:57.371]                     list(a = 1, b = 42L)
[01:28:57.371]                   }
[01:28:57.371]                 }, immediateCondition = function(cond) {
[01:28:57.371]                   sendCondition <- ...future.makeSendCondition()
[01:28:57.371]                   sendCondition(cond)
[01:28:57.371]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:57.371]                   {
[01:28:57.371]                     inherits <- base::inherits
[01:28:57.371]                     invokeRestart <- base::invokeRestart
[01:28:57.371]                     is.null <- base::is.null
[01:28:57.371]                     muffled <- FALSE
[01:28:57.371]                     if (inherits(cond, "message")) {
[01:28:57.371]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:57.371]                       if (muffled) 
[01:28:57.371]                         invokeRestart("muffleMessage")
[01:28:57.371]                     }
[01:28:57.371]                     else if (inherits(cond, "warning")) {
[01:28:57.371]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:57.371]                       if (muffled) 
[01:28:57.371]                         invokeRestart("muffleWarning")
[01:28:57.371]                     }
[01:28:57.371]                     else if (inherits(cond, "condition")) {
[01:28:57.371]                       if (!is.null(pattern)) {
[01:28:57.371]                         computeRestarts <- base::computeRestarts
[01:28:57.371]                         grepl <- base::grepl
[01:28:57.371]                         restarts <- computeRestarts(cond)
[01:28:57.371]                         for (restart in restarts) {
[01:28:57.371]                           name <- restart$name
[01:28:57.371]                           if (is.null(name)) 
[01:28:57.371]                             next
[01:28:57.371]                           if (!grepl(pattern, name)) 
[01:28:57.371]                             next
[01:28:57.371]                           invokeRestart(restart)
[01:28:57.371]                           muffled <- TRUE
[01:28:57.371]                           break
[01:28:57.371]                         }
[01:28:57.371]                       }
[01:28:57.371]                     }
[01:28:57.371]                     invisible(muffled)
[01:28:57.371]                   }
[01:28:57.371]                   muffleCondition(cond)
[01:28:57.371]                 })
[01:28:57.371]             }))
[01:28:57.371]             future::FutureResult(value = ...future.value$value, 
[01:28:57.371]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:57.371]                   ...future.rng), globalenv = if (FALSE) 
[01:28:57.371]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:57.371]                     ...future.globalenv.names))
[01:28:57.371]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:57.371]         }, condition = base::local({
[01:28:57.371]             c <- base::c
[01:28:57.371]             inherits <- base::inherits
[01:28:57.371]             invokeRestart <- base::invokeRestart
[01:28:57.371]             length <- base::length
[01:28:57.371]             list <- base::list
[01:28:57.371]             seq.int <- base::seq.int
[01:28:57.371]             signalCondition <- base::signalCondition
[01:28:57.371]             sys.calls <- base::sys.calls
[01:28:57.371]             `[[` <- base::`[[`
[01:28:57.371]             `+` <- base::`+`
[01:28:57.371]             `<<-` <- base::`<<-`
[01:28:57.371]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:57.371]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:57.371]                   3L)]
[01:28:57.371]             }
[01:28:57.371]             function(cond) {
[01:28:57.371]                 is_error <- inherits(cond, "error")
[01:28:57.371]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:57.371]                   NULL)
[01:28:57.371]                 if (is_error) {
[01:28:57.371]                   sessionInformation <- function() {
[01:28:57.371]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:57.371]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:57.371]                       search = base::search(), system = base::Sys.info())
[01:28:57.371]                   }
[01:28:57.371]                   ...future.conditions[[length(...future.conditions) + 
[01:28:57.371]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:57.371]                     cond$call), session = sessionInformation(), 
[01:28:57.371]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:57.371]                   signalCondition(cond)
[01:28:57.371]                 }
[01:28:57.371]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:57.371]                 "immediateCondition"))) {
[01:28:57.371]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:57.371]                   ...future.conditions[[length(...future.conditions) + 
[01:28:57.371]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:57.371]                   if (TRUE && !signal) {
[01:28:57.371]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:57.371]                     {
[01:28:57.371]                       inherits <- base::inherits
[01:28:57.371]                       invokeRestart <- base::invokeRestart
[01:28:57.371]                       is.null <- base::is.null
[01:28:57.371]                       muffled <- FALSE
[01:28:57.371]                       if (inherits(cond, "message")) {
[01:28:57.371]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:57.371]                         if (muffled) 
[01:28:57.371]                           invokeRestart("muffleMessage")
[01:28:57.371]                       }
[01:28:57.371]                       else if (inherits(cond, "warning")) {
[01:28:57.371]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:57.371]                         if (muffled) 
[01:28:57.371]                           invokeRestart("muffleWarning")
[01:28:57.371]                       }
[01:28:57.371]                       else if (inherits(cond, "condition")) {
[01:28:57.371]                         if (!is.null(pattern)) {
[01:28:57.371]                           computeRestarts <- base::computeRestarts
[01:28:57.371]                           grepl <- base::grepl
[01:28:57.371]                           restarts <- computeRestarts(cond)
[01:28:57.371]                           for (restart in restarts) {
[01:28:57.371]                             name <- restart$name
[01:28:57.371]                             if (is.null(name)) 
[01:28:57.371]                               next
[01:28:57.371]                             if (!grepl(pattern, name)) 
[01:28:57.371]                               next
[01:28:57.371]                             invokeRestart(restart)
[01:28:57.371]                             muffled <- TRUE
[01:28:57.371]                             break
[01:28:57.371]                           }
[01:28:57.371]                         }
[01:28:57.371]                       }
[01:28:57.371]                       invisible(muffled)
[01:28:57.371]                     }
[01:28:57.371]                     muffleCondition(cond, pattern = "^muffle")
[01:28:57.371]                   }
[01:28:57.371]                 }
[01:28:57.371]                 else {
[01:28:57.371]                   if (TRUE) {
[01:28:57.371]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:57.371]                     {
[01:28:57.371]                       inherits <- base::inherits
[01:28:57.371]                       invokeRestart <- base::invokeRestart
[01:28:57.371]                       is.null <- base::is.null
[01:28:57.371]                       muffled <- FALSE
[01:28:57.371]                       if (inherits(cond, "message")) {
[01:28:57.371]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:57.371]                         if (muffled) 
[01:28:57.371]                           invokeRestart("muffleMessage")
[01:28:57.371]                       }
[01:28:57.371]                       else if (inherits(cond, "warning")) {
[01:28:57.371]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:57.371]                         if (muffled) 
[01:28:57.371]                           invokeRestart("muffleWarning")
[01:28:57.371]                       }
[01:28:57.371]                       else if (inherits(cond, "condition")) {
[01:28:57.371]                         if (!is.null(pattern)) {
[01:28:57.371]                           computeRestarts <- base::computeRestarts
[01:28:57.371]                           grepl <- base::grepl
[01:28:57.371]                           restarts <- computeRestarts(cond)
[01:28:57.371]                           for (restart in restarts) {
[01:28:57.371]                             name <- restart$name
[01:28:57.371]                             if (is.null(name)) 
[01:28:57.371]                               next
[01:28:57.371]                             if (!grepl(pattern, name)) 
[01:28:57.371]                               next
[01:28:57.371]                             invokeRestart(restart)
[01:28:57.371]                             muffled <- TRUE
[01:28:57.371]                             break
[01:28:57.371]                           }
[01:28:57.371]                         }
[01:28:57.371]                       }
[01:28:57.371]                       invisible(muffled)
[01:28:57.371]                     }
[01:28:57.371]                     muffleCondition(cond, pattern = "^muffle")
[01:28:57.371]                   }
[01:28:57.371]                 }
[01:28:57.371]             }
[01:28:57.371]         }))
[01:28:57.371]     }, error = function(ex) {
[01:28:57.371]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:57.371]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:57.371]                 ...future.rng), started = ...future.startTime, 
[01:28:57.371]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:57.371]             version = "1.8"), class = "FutureResult")
[01:28:57.371]     }, finally = {
[01:28:57.371]         if (!identical(...future.workdir, getwd())) 
[01:28:57.371]             setwd(...future.workdir)
[01:28:57.371]         {
[01:28:57.371]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:57.371]                 ...future.oldOptions$nwarnings <- NULL
[01:28:57.371]             }
[01:28:57.371]             base::options(...future.oldOptions)
[01:28:57.371]             if (.Platform$OS.type == "windows") {
[01:28:57.371]                 old_names <- names(...future.oldEnvVars)
[01:28:57.371]                 envs <- base::Sys.getenv()
[01:28:57.371]                 names <- names(envs)
[01:28:57.371]                 common <- intersect(names, old_names)
[01:28:57.371]                 added <- setdiff(names, old_names)
[01:28:57.371]                 removed <- setdiff(old_names, names)
[01:28:57.371]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:57.371]                   envs[common]]
[01:28:57.371]                 NAMES <- toupper(changed)
[01:28:57.371]                 args <- list()
[01:28:57.371]                 for (kk in seq_along(NAMES)) {
[01:28:57.371]                   name <- changed[[kk]]
[01:28:57.371]                   NAME <- NAMES[[kk]]
[01:28:57.371]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:57.371]                     next
[01:28:57.371]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:57.371]                 }
[01:28:57.371]                 NAMES <- toupper(added)
[01:28:57.371]                 for (kk in seq_along(NAMES)) {
[01:28:57.371]                   name <- added[[kk]]
[01:28:57.371]                   NAME <- NAMES[[kk]]
[01:28:57.371]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:57.371]                     next
[01:28:57.371]                   args[[name]] <- ""
[01:28:57.371]                 }
[01:28:57.371]                 NAMES <- toupper(removed)
[01:28:57.371]                 for (kk in seq_along(NAMES)) {
[01:28:57.371]                   name <- removed[[kk]]
[01:28:57.371]                   NAME <- NAMES[[kk]]
[01:28:57.371]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:57.371]                     next
[01:28:57.371]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:57.371]                 }
[01:28:57.371]                 if (length(args) > 0) 
[01:28:57.371]                   base::do.call(base::Sys.setenv, args = args)
[01:28:57.371]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:57.371]             }
[01:28:57.371]             else {
[01:28:57.371]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:57.371]             }
[01:28:57.371]             {
[01:28:57.371]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:57.371]                   0L) {
[01:28:57.371]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:57.371]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:57.371]                   base::options(opts)
[01:28:57.371]                 }
[01:28:57.371]                 {
[01:28:57.371]                   {
[01:28:57.371]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:57.371]                     NULL
[01:28:57.371]                   }
[01:28:57.371]                   options(future.plan = NULL)
[01:28:57.371]                   if (is.na(NA_character_)) 
[01:28:57.371]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:57.371]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:57.371]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:57.371]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:57.371]                     envir = parent.frame()) 
[01:28:57.371]                   {
[01:28:57.371]                     if (is.function(workers)) 
[01:28:57.371]                       workers <- workers()
[01:28:57.371]                     workers <- structure(as.integer(workers), 
[01:28:57.371]                       class = class(workers))
[01:28:57.371]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:57.371]                       workers >= 1)
[01:28:57.371]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:57.371]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:57.371]                     }
[01:28:57.371]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:57.371]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:57.371]                       envir = envir)
[01:28:57.371]                     if (!future$lazy) 
[01:28:57.371]                       future <- run(future)
[01:28:57.371]                     invisible(future)
[01:28:57.371]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:57.371]                 }
[01:28:57.371]             }
[01:28:57.371]         }
[01:28:57.371]     })
[01:28:57.371]     if (TRUE) {
[01:28:57.371]         base::sink(type = "output", split = FALSE)
[01:28:57.371]         if (TRUE) {
[01:28:57.371]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:57.371]         }
[01:28:57.371]         else {
[01:28:57.371]             ...future.result["stdout"] <- base::list(NULL)
[01:28:57.371]         }
[01:28:57.371]         base::close(...future.stdout)
[01:28:57.371]         ...future.stdout <- NULL
[01:28:57.371]     }
[01:28:57.371]     ...future.result$conditions <- ...future.conditions
[01:28:57.371]     ...future.result$finished <- base::Sys.time()
[01:28:57.371]     ...future.result
[01:28:57.371] }
[01:28:57.377] MultisessionFuture started
[01:28:57.378] - Launch lazy future ... done
[01:28:57.378] run() for 'MultisessionFuture' ... done
[01:28:57.909] receiveMessageFromWorker() for ClusterFuture ...
[01:28:57.910] - Validating connection of MultisessionFuture
[01:28:57.910] - received message: FutureResult
[01:28:57.910] - Received FutureResult
[01:28:57.911] - Erased future from FutureRegistry
[01:28:57.911] result() for ClusterFuture ...
[01:28:57.911] - result already collected: FutureResult
[01:28:57.911] result() for ClusterFuture ... done
[01:28:57.911] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:57.911] A MultisessionFuture was resolved (result was not collected)
[01:28:57.912] getGlobalsAndPackages() ...
[01:28:57.912] Searching for globals...
[01:28:57.913] - globals found: [3] '{', 'Sys.sleep', 'list'
[01:28:57.914] Searching for globals ... DONE
[01:28:57.914] Resolving globals: FALSE
[01:28:57.914] 
[01:28:57.914] 
[01:28:57.914] getGlobalsAndPackages() ... DONE
[01:28:57.915] run() for 'Future' ...
[01:28:57.915] - state: 'created'
[01:28:57.915] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:57.930] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:57.930] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:57.930]   - Field: 'node'
[01:28:57.930]   - Field: 'label'
[01:28:57.931]   - Field: 'local'
[01:28:57.931]   - Field: 'owner'
[01:28:57.931]   - Field: 'envir'
[01:28:57.931]   - Field: 'workers'
[01:28:57.931]   - Field: 'packages'
[01:28:57.931]   - Field: 'gc'
[01:28:57.932]   - Field: 'conditions'
[01:28:57.932]   - Field: 'persistent'
[01:28:57.932]   - Field: 'expr'
[01:28:57.932]   - Field: 'uuid'
[01:28:57.932]   - Field: 'seed'
[01:28:57.933]   - Field: 'version'
[01:28:57.933]   - Field: 'result'
[01:28:57.933]   - Field: 'asynchronous'
[01:28:57.933]   - Field: 'calls'
[01:28:57.933]   - Field: 'globals'
[01:28:57.933]   - Field: 'stdout'
[01:28:57.934]   - Field: 'earlySignal'
[01:28:57.934]   - Field: 'lazy'
[01:28:57.934]   - Field: 'state'
[01:28:57.934] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:57.934] - Launch lazy future ...
[01:28:57.935] Packages needed by the future expression (n = 0): <none>
[01:28:57.935] Packages needed by future strategies (n = 0): <none>
[01:28:57.935] {
[01:28:57.935]     {
[01:28:57.935]         {
[01:28:57.935]             ...future.startTime <- base::Sys.time()
[01:28:57.935]             {
[01:28:57.935]                 {
[01:28:57.935]                   {
[01:28:57.935]                     {
[01:28:57.935]                       base::local({
[01:28:57.935]                         has_future <- base::requireNamespace("future", 
[01:28:57.935]                           quietly = TRUE)
[01:28:57.935]                         if (has_future) {
[01:28:57.935]                           ns <- base::getNamespace("future")
[01:28:57.935]                           version <- ns[[".package"]][["version"]]
[01:28:57.935]                           if (is.null(version)) 
[01:28:57.935]                             version <- utils::packageVersion("future")
[01:28:57.935]                         }
[01:28:57.935]                         else {
[01:28:57.935]                           version <- NULL
[01:28:57.935]                         }
[01:28:57.935]                         if (!has_future || version < "1.8.0") {
[01:28:57.935]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:57.935]                             "", base::R.version$version.string), 
[01:28:57.935]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:57.935]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:57.935]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:57.935]                               "release", "version")], collapse = " "), 
[01:28:57.935]                             hostname = base::Sys.info()[["nodename"]])
[01:28:57.935]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:57.935]                             info)
[01:28:57.935]                           info <- base::paste(info, collapse = "; ")
[01:28:57.935]                           if (!has_future) {
[01:28:57.935]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:57.935]                               info)
[01:28:57.935]                           }
[01:28:57.935]                           else {
[01:28:57.935]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:57.935]                               info, version)
[01:28:57.935]                           }
[01:28:57.935]                           base::stop(msg)
[01:28:57.935]                         }
[01:28:57.935]                       })
[01:28:57.935]                     }
[01:28:57.935]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:57.935]                     base::options(mc.cores = 1L)
[01:28:57.935]                   }
[01:28:57.935]                   options(future.plan = NULL)
[01:28:57.935]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:57.935]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:57.935]                 }
[01:28:57.935]                 ...future.workdir <- getwd()
[01:28:57.935]             }
[01:28:57.935]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:57.935]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:57.935]         }
[01:28:57.935]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:57.935]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:57.935]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:57.935]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:57.935]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:57.935]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:57.935]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:57.935]             base::names(...future.oldOptions))
[01:28:57.935]     }
[01:28:57.935]     if (FALSE) {
[01:28:57.935]     }
[01:28:57.935]     else {
[01:28:57.935]         if (TRUE) {
[01:28:57.935]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:57.935]                 open = "w")
[01:28:57.935]         }
[01:28:57.935]         else {
[01:28:57.935]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:57.935]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:57.935]         }
[01:28:57.935]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:57.935]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:57.935]             base::sink(type = "output", split = FALSE)
[01:28:57.935]             base::close(...future.stdout)
[01:28:57.935]         }, add = TRUE)
[01:28:57.935]     }
[01:28:57.935]     ...future.frame <- base::sys.nframe()
[01:28:57.935]     ...future.conditions <- base::list()
[01:28:57.935]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:57.935]     if (FALSE) {
[01:28:57.935]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:57.935]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:57.935]     }
[01:28:57.935]     ...future.result <- base::tryCatch({
[01:28:57.935]         base::withCallingHandlers({
[01:28:57.935]             ...future.value <- base::withVisible(base::local({
[01:28:57.935]                 ...future.makeSendCondition <- base::local({
[01:28:57.935]                   sendCondition <- NULL
[01:28:57.935]                   function(frame = 1L) {
[01:28:57.935]                     if (is.function(sendCondition)) 
[01:28:57.935]                       return(sendCondition)
[01:28:57.935]                     ns <- getNamespace("parallel")
[01:28:57.935]                     if (exists("sendData", mode = "function", 
[01:28:57.935]                       envir = ns)) {
[01:28:57.935]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:57.935]                         envir = ns)
[01:28:57.935]                       envir <- sys.frame(frame)
[01:28:57.935]                       master <- NULL
[01:28:57.935]                       while (!identical(envir, .GlobalEnv) && 
[01:28:57.935]                         !identical(envir, emptyenv())) {
[01:28:57.935]                         if (exists("master", mode = "list", envir = envir, 
[01:28:57.935]                           inherits = FALSE)) {
[01:28:57.935]                           master <- get("master", mode = "list", 
[01:28:57.935]                             envir = envir, inherits = FALSE)
[01:28:57.935]                           if (inherits(master, c("SOCKnode", 
[01:28:57.935]                             "SOCK0node"))) {
[01:28:57.935]                             sendCondition <<- function(cond) {
[01:28:57.935]                               data <- list(type = "VALUE", value = cond, 
[01:28:57.935]                                 success = TRUE)
[01:28:57.935]                               parallel_sendData(master, data)
[01:28:57.935]                             }
[01:28:57.935]                             return(sendCondition)
[01:28:57.935]                           }
[01:28:57.935]                         }
[01:28:57.935]                         frame <- frame + 1L
[01:28:57.935]                         envir <- sys.frame(frame)
[01:28:57.935]                       }
[01:28:57.935]                     }
[01:28:57.935]                     sendCondition <<- function(cond) NULL
[01:28:57.935]                   }
[01:28:57.935]                 })
[01:28:57.935]                 withCallingHandlers({
[01:28:57.935]                   {
[01:28:57.935]                     Sys.sleep(0.5)
[01:28:57.935]                     list(a = 1, b = 42L)
[01:28:57.935]                   }
[01:28:57.935]                 }, immediateCondition = function(cond) {
[01:28:57.935]                   sendCondition <- ...future.makeSendCondition()
[01:28:57.935]                   sendCondition(cond)
[01:28:57.935]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:57.935]                   {
[01:28:57.935]                     inherits <- base::inherits
[01:28:57.935]                     invokeRestart <- base::invokeRestart
[01:28:57.935]                     is.null <- base::is.null
[01:28:57.935]                     muffled <- FALSE
[01:28:57.935]                     if (inherits(cond, "message")) {
[01:28:57.935]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:57.935]                       if (muffled) 
[01:28:57.935]                         invokeRestart("muffleMessage")
[01:28:57.935]                     }
[01:28:57.935]                     else if (inherits(cond, "warning")) {
[01:28:57.935]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:57.935]                       if (muffled) 
[01:28:57.935]                         invokeRestart("muffleWarning")
[01:28:57.935]                     }
[01:28:57.935]                     else if (inherits(cond, "condition")) {
[01:28:57.935]                       if (!is.null(pattern)) {
[01:28:57.935]                         computeRestarts <- base::computeRestarts
[01:28:57.935]                         grepl <- base::grepl
[01:28:57.935]                         restarts <- computeRestarts(cond)
[01:28:57.935]                         for (restart in restarts) {
[01:28:57.935]                           name <- restart$name
[01:28:57.935]                           if (is.null(name)) 
[01:28:57.935]                             next
[01:28:57.935]                           if (!grepl(pattern, name)) 
[01:28:57.935]                             next
[01:28:57.935]                           invokeRestart(restart)
[01:28:57.935]                           muffled <- TRUE
[01:28:57.935]                           break
[01:28:57.935]                         }
[01:28:57.935]                       }
[01:28:57.935]                     }
[01:28:57.935]                     invisible(muffled)
[01:28:57.935]                   }
[01:28:57.935]                   muffleCondition(cond)
[01:28:57.935]                 })
[01:28:57.935]             }))
[01:28:57.935]             future::FutureResult(value = ...future.value$value, 
[01:28:57.935]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:57.935]                   ...future.rng), globalenv = if (FALSE) 
[01:28:57.935]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:57.935]                     ...future.globalenv.names))
[01:28:57.935]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:57.935]         }, condition = base::local({
[01:28:57.935]             c <- base::c
[01:28:57.935]             inherits <- base::inherits
[01:28:57.935]             invokeRestart <- base::invokeRestart
[01:28:57.935]             length <- base::length
[01:28:57.935]             list <- base::list
[01:28:57.935]             seq.int <- base::seq.int
[01:28:57.935]             signalCondition <- base::signalCondition
[01:28:57.935]             sys.calls <- base::sys.calls
[01:28:57.935]             `[[` <- base::`[[`
[01:28:57.935]             `+` <- base::`+`
[01:28:57.935]             `<<-` <- base::`<<-`
[01:28:57.935]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:57.935]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:57.935]                   3L)]
[01:28:57.935]             }
[01:28:57.935]             function(cond) {
[01:28:57.935]                 is_error <- inherits(cond, "error")
[01:28:57.935]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:57.935]                   NULL)
[01:28:57.935]                 if (is_error) {
[01:28:57.935]                   sessionInformation <- function() {
[01:28:57.935]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:57.935]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:57.935]                       search = base::search(), system = base::Sys.info())
[01:28:57.935]                   }
[01:28:57.935]                   ...future.conditions[[length(...future.conditions) + 
[01:28:57.935]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:57.935]                     cond$call), session = sessionInformation(), 
[01:28:57.935]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:57.935]                   signalCondition(cond)
[01:28:57.935]                 }
[01:28:57.935]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:57.935]                 "immediateCondition"))) {
[01:28:57.935]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:57.935]                   ...future.conditions[[length(...future.conditions) + 
[01:28:57.935]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:57.935]                   if (TRUE && !signal) {
[01:28:57.935]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:57.935]                     {
[01:28:57.935]                       inherits <- base::inherits
[01:28:57.935]                       invokeRestart <- base::invokeRestart
[01:28:57.935]                       is.null <- base::is.null
[01:28:57.935]                       muffled <- FALSE
[01:28:57.935]                       if (inherits(cond, "message")) {
[01:28:57.935]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:57.935]                         if (muffled) 
[01:28:57.935]                           invokeRestart("muffleMessage")
[01:28:57.935]                       }
[01:28:57.935]                       else if (inherits(cond, "warning")) {
[01:28:57.935]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:57.935]                         if (muffled) 
[01:28:57.935]                           invokeRestart("muffleWarning")
[01:28:57.935]                       }
[01:28:57.935]                       else if (inherits(cond, "condition")) {
[01:28:57.935]                         if (!is.null(pattern)) {
[01:28:57.935]                           computeRestarts <- base::computeRestarts
[01:28:57.935]                           grepl <- base::grepl
[01:28:57.935]                           restarts <- computeRestarts(cond)
[01:28:57.935]                           for (restart in restarts) {
[01:28:57.935]                             name <- restart$name
[01:28:57.935]                             if (is.null(name)) 
[01:28:57.935]                               next
[01:28:57.935]                             if (!grepl(pattern, name)) 
[01:28:57.935]                               next
[01:28:57.935]                             invokeRestart(restart)
[01:28:57.935]                             muffled <- TRUE
[01:28:57.935]                             break
[01:28:57.935]                           }
[01:28:57.935]                         }
[01:28:57.935]                       }
[01:28:57.935]                       invisible(muffled)
[01:28:57.935]                     }
[01:28:57.935]                     muffleCondition(cond, pattern = "^muffle")
[01:28:57.935]                   }
[01:28:57.935]                 }
[01:28:57.935]                 else {
[01:28:57.935]                   if (TRUE) {
[01:28:57.935]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:57.935]                     {
[01:28:57.935]                       inherits <- base::inherits
[01:28:57.935]                       invokeRestart <- base::invokeRestart
[01:28:57.935]                       is.null <- base::is.null
[01:28:57.935]                       muffled <- FALSE
[01:28:57.935]                       if (inherits(cond, "message")) {
[01:28:57.935]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:57.935]                         if (muffled) 
[01:28:57.935]                           invokeRestart("muffleMessage")
[01:28:57.935]                       }
[01:28:57.935]                       else if (inherits(cond, "warning")) {
[01:28:57.935]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:57.935]                         if (muffled) 
[01:28:57.935]                           invokeRestart("muffleWarning")
[01:28:57.935]                       }
[01:28:57.935]                       else if (inherits(cond, "condition")) {
[01:28:57.935]                         if (!is.null(pattern)) {
[01:28:57.935]                           computeRestarts <- base::computeRestarts
[01:28:57.935]                           grepl <- base::grepl
[01:28:57.935]                           restarts <- computeRestarts(cond)
[01:28:57.935]                           for (restart in restarts) {
[01:28:57.935]                             name <- restart$name
[01:28:57.935]                             if (is.null(name)) 
[01:28:57.935]                               next
[01:28:57.935]                             if (!grepl(pattern, name)) 
[01:28:57.935]                               next
[01:28:57.935]                             invokeRestart(restart)
[01:28:57.935]                             muffled <- TRUE
[01:28:57.935]                             break
[01:28:57.935]                           }
[01:28:57.935]                         }
[01:28:57.935]                       }
[01:28:57.935]                       invisible(muffled)
[01:28:57.935]                     }
[01:28:57.935]                     muffleCondition(cond, pattern = "^muffle")
[01:28:57.935]                   }
[01:28:57.935]                 }
[01:28:57.935]             }
[01:28:57.935]         }))
[01:28:57.935]     }, error = function(ex) {
[01:28:57.935]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:57.935]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:57.935]                 ...future.rng), started = ...future.startTime, 
[01:28:57.935]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:57.935]             version = "1.8"), class = "FutureResult")
[01:28:57.935]     }, finally = {
[01:28:57.935]         if (!identical(...future.workdir, getwd())) 
[01:28:57.935]             setwd(...future.workdir)
[01:28:57.935]         {
[01:28:57.935]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:57.935]                 ...future.oldOptions$nwarnings <- NULL
[01:28:57.935]             }
[01:28:57.935]             base::options(...future.oldOptions)
[01:28:57.935]             if (.Platform$OS.type == "windows") {
[01:28:57.935]                 old_names <- names(...future.oldEnvVars)
[01:28:57.935]                 envs <- base::Sys.getenv()
[01:28:57.935]                 names <- names(envs)
[01:28:57.935]                 common <- intersect(names, old_names)
[01:28:57.935]                 added <- setdiff(names, old_names)
[01:28:57.935]                 removed <- setdiff(old_names, names)
[01:28:57.935]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:57.935]                   envs[common]]
[01:28:57.935]                 NAMES <- toupper(changed)
[01:28:57.935]                 args <- list()
[01:28:57.935]                 for (kk in seq_along(NAMES)) {
[01:28:57.935]                   name <- changed[[kk]]
[01:28:57.935]                   NAME <- NAMES[[kk]]
[01:28:57.935]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:57.935]                     next
[01:28:57.935]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:57.935]                 }
[01:28:57.935]                 NAMES <- toupper(added)
[01:28:57.935]                 for (kk in seq_along(NAMES)) {
[01:28:57.935]                   name <- added[[kk]]
[01:28:57.935]                   NAME <- NAMES[[kk]]
[01:28:57.935]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:57.935]                     next
[01:28:57.935]                   args[[name]] <- ""
[01:28:57.935]                 }
[01:28:57.935]                 NAMES <- toupper(removed)
[01:28:57.935]                 for (kk in seq_along(NAMES)) {
[01:28:57.935]                   name <- removed[[kk]]
[01:28:57.935]                   NAME <- NAMES[[kk]]
[01:28:57.935]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:57.935]                     next
[01:28:57.935]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:57.935]                 }
[01:28:57.935]                 if (length(args) > 0) 
[01:28:57.935]                   base::do.call(base::Sys.setenv, args = args)
[01:28:57.935]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:57.935]             }
[01:28:57.935]             else {
[01:28:57.935]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:57.935]             }
[01:28:57.935]             {
[01:28:57.935]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:57.935]                   0L) {
[01:28:57.935]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:57.935]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:57.935]                   base::options(opts)
[01:28:57.935]                 }
[01:28:57.935]                 {
[01:28:57.935]                   {
[01:28:57.935]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:57.935]                     NULL
[01:28:57.935]                   }
[01:28:57.935]                   options(future.plan = NULL)
[01:28:57.935]                   if (is.na(NA_character_)) 
[01:28:57.935]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:57.935]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:57.935]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:57.935]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:57.935]                     envir = parent.frame()) 
[01:28:57.935]                   {
[01:28:57.935]                     if (is.function(workers)) 
[01:28:57.935]                       workers <- workers()
[01:28:57.935]                     workers <- structure(as.integer(workers), 
[01:28:57.935]                       class = class(workers))
[01:28:57.935]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:57.935]                       workers >= 1)
[01:28:57.935]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:57.935]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:57.935]                     }
[01:28:57.935]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:57.935]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:57.935]                       envir = envir)
[01:28:57.935]                     if (!future$lazy) 
[01:28:57.935]                       future <- run(future)
[01:28:57.935]                     invisible(future)
[01:28:57.935]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:57.935]                 }
[01:28:57.935]             }
[01:28:57.935]         }
[01:28:57.935]     })
[01:28:57.935]     if (TRUE) {
[01:28:57.935]         base::sink(type = "output", split = FALSE)
[01:28:57.935]         if (TRUE) {
[01:28:57.935]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:57.935]         }
[01:28:57.935]         else {
[01:28:57.935]             ...future.result["stdout"] <- base::list(NULL)
[01:28:57.935]         }
[01:28:57.935]         base::close(...future.stdout)
[01:28:57.935]         ...future.stdout <- NULL
[01:28:57.935]     }
[01:28:57.935]     ...future.result$conditions <- ...future.conditions
[01:28:57.935]     ...future.result$finished <- base::Sys.time()
[01:28:57.935]     ...future.result
[01:28:57.935] }
[01:28:57.941] MultisessionFuture started
[01:28:57.942] - Launch lazy future ... done
[01:28:57.942] run() for 'MultisessionFuture' ... done
[01:28:58.475] receiveMessageFromWorker() for ClusterFuture ...
[01:28:58.475] - Validating connection of MultisessionFuture
[01:28:58.475] - received message: FutureResult
[01:28:58.476] - Received FutureResult
[01:28:58.476] - Erased future from FutureRegistry
[01:28:58.476] result() for ClusterFuture ...
[01:28:58.476] - result already collected: FutureResult
[01:28:58.476] result() for ClusterFuture ... done
[01:28:58.477] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:58.477] A MultisessionFuture was resolved (result was not collected)
- w/ exception ...
[01:28:58.477] getGlobalsAndPackages() ...
[01:28:58.477] Searching for globals...
[01:28:58.478] - globals found: [2] 'list', 'stop'
[01:28:58.478] Searching for globals ... DONE
[01:28:58.479] Resolving globals: FALSE
[01:28:58.479] 
[01:28:58.479] 
[01:28:58.479] getGlobalsAndPackages() ... DONE
[01:28:58.480] run() for 'Future' ...
[01:28:58.480] - state: 'created'
[01:28:58.480] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:58.495] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:58.495] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:58.495]   - Field: 'node'
[01:28:58.495]   - Field: 'label'
[01:28:58.495]   - Field: 'local'
[01:28:58.496]   - Field: 'owner'
[01:28:58.496]   - Field: 'envir'
[01:28:58.496]   - Field: 'workers'
[01:28:58.496]   - Field: 'packages'
[01:28:58.496]   - Field: 'gc'
[01:28:58.497]   - Field: 'conditions'
[01:28:58.497]   - Field: 'persistent'
[01:28:58.497]   - Field: 'expr'
[01:28:58.497]   - Field: 'uuid'
[01:28:58.497]   - Field: 'seed'
[01:28:58.497]   - Field: 'version'
[01:28:58.498]   - Field: 'result'
[01:28:58.498]   - Field: 'asynchronous'
[01:28:58.498]   - Field: 'calls'
[01:28:58.498]   - Field: 'globals'
[01:28:58.498]   - Field: 'stdout'
[01:28:58.498]   - Field: 'earlySignal'
[01:28:58.499]   - Field: 'lazy'
[01:28:58.499]   - Field: 'state'
[01:28:58.499] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:58.499] - Launch lazy future ...
[01:28:58.500] Packages needed by the future expression (n = 0): <none>
[01:28:58.500] Packages needed by future strategies (n = 0): <none>
[01:28:58.500] {
[01:28:58.500]     {
[01:28:58.500]         {
[01:28:58.500]             ...future.startTime <- base::Sys.time()
[01:28:58.500]             {
[01:28:58.500]                 {
[01:28:58.500]                   {
[01:28:58.500]                     {
[01:28:58.500]                       base::local({
[01:28:58.500]                         has_future <- base::requireNamespace("future", 
[01:28:58.500]                           quietly = TRUE)
[01:28:58.500]                         if (has_future) {
[01:28:58.500]                           ns <- base::getNamespace("future")
[01:28:58.500]                           version <- ns[[".package"]][["version"]]
[01:28:58.500]                           if (is.null(version)) 
[01:28:58.500]                             version <- utils::packageVersion("future")
[01:28:58.500]                         }
[01:28:58.500]                         else {
[01:28:58.500]                           version <- NULL
[01:28:58.500]                         }
[01:28:58.500]                         if (!has_future || version < "1.8.0") {
[01:28:58.500]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:58.500]                             "", base::R.version$version.string), 
[01:28:58.500]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:58.500]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:58.500]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:58.500]                               "release", "version")], collapse = " "), 
[01:28:58.500]                             hostname = base::Sys.info()[["nodename"]])
[01:28:58.500]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:58.500]                             info)
[01:28:58.500]                           info <- base::paste(info, collapse = "; ")
[01:28:58.500]                           if (!has_future) {
[01:28:58.500]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:58.500]                               info)
[01:28:58.500]                           }
[01:28:58.500]                           else {
[01:28:58.500]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:58.500]                               info, version)
[01:28:58.500]                           }
[01:28:58.500]                           base::stop(msg)
[01:28:58.500]                         }
[01:28:58.500]                       })
[01:28:58.500]                     }
[01:28:58.500]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:58.500]                     base::options(mc.cores = 1L)
[01:28:58.500]                   }
[01:28:58.500]                   options(future.plan = NULL)
[01:28:58.500]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:58.500]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:58.500]                 }
[01:28:58.500]                 ...future.workdir <- getwd()
[01:28:58.500]             }
[01:28:58.500]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:58.500]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:58.500]         }
[01:28:58.500]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:58.500]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:58.500]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:58.500]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:58.500]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:58.500]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:58.500]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:58.500]             base::names(...future.oldOptions))
[01:28:58.500]     }
[01:28:58.500]     if (FALSE) {
[01:28:58.500]     }
[01:28:58.500]     else {
[01:28:58.500]         if (TRUE) {
[01:28:58.500]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:58.500]                 open = "w")
[01:28:58.500]         }
[01:28:58.500]         else {
[01:28:58.500]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:58.500]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:58.500]         }
[01:28:58.500]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:58.500]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:58.500]             base::sink(type = "output", split = FALSE)
[01:28:58.500]             base::close(...future.stdout)
[01:28:58.500]         }, add = TRUE)
[01:28:58.500]     }
[01:28:58.500]     ...future.frame <- base::sys.nframe()
[01:28:58.500]     ...future.conditions <- base::list()
[01:28:58.500]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:58.500]     if (FALSE) {
[01:28:58.500]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:58.500]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:58.500]     }
[01:28:58.500]     ...future.result <- base::tryCatch({
[01:28:58.500]         base::withCallingHandlers({
[01:28:58.500]             ...future.value <- base::withVisible(base::local({
[01:28:58.500]                 ...future.makeSendCondition <- base::local({
[01:28:58.500]                   sendCondition <- NULL
[01:28:58.500]                   function(frame = 1L) {
[01:28:58.500]                     if (is.function(sendCondition)) 
[01:28:58.500]                       return(sendCondition)
[01:28:58.500]                     ns <- getNamespace("parallel")
[01:28:58.500]                     if (exists("sendData", mode = "function", 
[01:28:58.500]                       envir = ns)) {
[01:28:58.500]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:58.500]                         envir = ns)
[01:28:58.500]                       envir <- sys.frame(frame)
[01:28:58.500]                       master <- NULL
[01:28:58.500]                       while (!identical(envir, .GlobalEnv) && 
[01:28:58.500]                         !identical(envir, emptyenv())) {
[01:28:58.500]                         if (exists("master", mode = "list", envir = envir, 
[01:28:58.500]                           inherits = FALSE)) {
[01:28:58.500]                           master <- get("master", mode = "list", 
[01:28:58.500]                             envir = envir, inherits = FALSE)
[01:28:58.500]                           if (inherits(master, c("SOCKnode", 
[01:28:58.500]                             "SOCK0node"))) {
[01:28:58.500]                             sendCondition <<- function(cond) {
[01:28:58.500]                               data <- list(type = "VALUE", value = cond, 
[01:28:58.500]                                 success = TRUE)
[01:28:58.500]                               parallel_sendData(master, data)
[01:28:58.500]                             }
[01:28:58.500]                             return(sendCondition)
[01:28:58.500]                           }
[01:28:58.500]                         }
[01:28:58.500]                         frame <- frame + 1L
[01:28:58.500]                         envir <- sys.frame(frame)
[01:28:58.500]                       }
[01:28:58.500]                     }
[01:28:58.500]                     sendCondition <<- function(cond) NULL
[01:28:58.500]                   }
[01:28:58.500]                 })
[01:28:58.500]                 withCallingHandlers({
[01:28:58.500]                   list(a = 1, b = 42L, c = stop("Nah!"))
[01:28:58.500]                 }, immediateCondition = function(cond) {
[01:28:58.500]                   sendCondition <- ...future.makeSendCondition()
[01:28:58.500]                   sendCondition(cond)
[01:28:58.500]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:58.500]                   {
[01:28:58.500]                     inherits <- base::inherits
[01:28:58.500]                     invokeRestart <- base::invokeRestart
[01:28:58.500]                     is.null <- base::is.null
[01:28:58.500]                     muffled <- FALSE
[01:28:58.500]                     if (inherits(cond, "message")) {
[01:28:58.500]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:58.500]                       if (muffled) 
[01:28:58.500]                         invokeRestart("muffleMessage")
[01:28:58.500]                     }
[01:28:58.500]                     else if (inherits(cond, "warning")) {
[01:28:58.500]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:58.500]                       if (muffled) 
[01:28:58.500]                         invokeRestart("muffleWarning")
[01:28:58.500]                     }
[01:28:58.500]                     else if (inherits(cond, "condition")) {
[01:28:58.500]                       if (!is.null(pattern)) {
[01:28:58.500]                         computeRestarts <- base::computeRestarts
[01:28:58.500]                         grepl <- base::grepl
[01:28:58.500]                         restarts <- computeRestarts(cond)
[01:28:58.500]                         for (restart in restarts) {
[01:28:58.500]                           name <- restart$name
[01:28:58.500]                           if (is.null(name)) 
[01:28:58.500]                             next
[01:28:58.500]                           if (!grepl(pattern, name)) 
[01:28:58.500]                             next
[01:28:58.500]                           invokeRestart(restart)
[01:28:58.500]                           muffled <- TRUE
[01:28:58.500]                           break
[01:28:58.500]                         }
[01:28:58.500]                       }
[01:28:58.500]                     }
[01:28:58.500]                     invisible(muffled)
[01:28:58.500]                   }
[01:28:58.500]                   muffleCondition(cond)
[01:28:58.500]                 })
[01:28:58.500]             }))
[01:28:58.500]             future::FutureResult(value = ...future.value$value, 
[01:28:58.500]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:58.500]                   ...future.rng), globalenv = if (FALSE) 
[01:28:58.500]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:58.500]                     ...future.globalenv.names))
[01:28:58.500]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:58.500]         }, condition = base::local({
[01:28:58.500]             c <- base::c
[01:28:58.500]             inherits <- base::inherits
[01:28:58.500]             invokeRestart <- base::invokeRestart
[01:28:58.500]             length <- base::length
[01:28:58.500]             list <- base::list
[01:28:58.500]             seq.int <- base::seq.int
[01:28:58.500]             signalCondition <- base::signalCondition
[01:28:58.500]             sys.calls <- base::sys.calls
[01:28:58.500]             `[[` <- base::`[[`
[01:28:58.500]             `+` <- base::`+`
[01:28:58.500]             `<<-` <- base::`<<-`
[01:28:58.500]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:58.500]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:58.500]                   3L)]
[01:28:58.500]             }
[01:28:58.500]             function(cond) {
[01:28:58.500]                 is_error <- inherits(cond, "error")
[01:28:58.500]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:58.500]                   NULL)
[01:28:58.500]                 if (is_error) {
[01:28:58.500]                   sessionInformation <- function() {
[01:28:58.500]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:58.500]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:58.500]                       search = base::search(), system = base::Sys.info())
[01:28:58.500]                   }
[01:28:58.500]                   ...future.conditions[[length(...future.conditions) + 
[01:28:58.500]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:58.500]                     cond$call), session = sessionInformation(), 
[01:28:58.500]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:58.500]                   signalCondition(cond)
[01:28:58.500]                 }
[01:28:58.500]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:58.500]                 "immediateCondition"))) {
[01:28:58.500]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:58.500]                   ...future.conditions[[length(...future.conditions) + 
[01:28:58.500]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:58.500]                   if (TRUE && !signal) {
[01:28:58.500]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:58.500]                     {
[01:28:58.500]                       inherits <- base::inherits
[01:28:58.500]                       invokeRestart <- base::invokeRestart
[01:28:58.500]                       is.null <- base::is.null
[01:28:58.500]                       muffled <- FALSE
[01:28:58.500]                       if (inherits(cond, "message")) {
[01:28:58.500]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:58.500]                         if (muffled) 
[01:28:58.500]                           invokeRestart("muffleMessage")
[01:28:58.500]                       }
[01:28:58.500]                       else if (inherits(cond, "warning")) {
[01:28:58.500]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:58.500]                         if (muffled) 
[01:28:58.500]                           invokeRestart("muffleWarning")
[01:28:58.500]                       }
[01:28:58.500]                       else if (inherits(cond, "condition")) {
[01:28:58.500]                         if (!is.null(pattern)) {
[01:28:58.500]                           computeRestarts <- base::computeRestarts
[01:28:58.500]                           grepl <- base::grepl
[01:28:58.500]                           restarts <- computeRestarts(cond)
[01:28:58.500]                           for (restart in restarts) {
[01:28:58.500]                             name <- restart$name
[01:28:58.500]                             if (is.null(name)) 
[01:28:58.500]                               next
[01:28:58.500]                             if (!grepl(pattern, name)) 
[01:28:58.500]                               next
[01:28:58.500]                             invokeRestart(restart)
[01:28:58.500]                             muffled <- TRUE
[01:28:58.500]                             break
[01:28:58.500]                           }
[01:28:58.500]                         }
[01:28:58.500]                       }
[01:28:58.500]                       invisible(muffled)
[01:28:58.500]                     }
[01:28:58.500]                     muffleCondition(cond, pattern = "^muffle")
[01:28:58.500]                   }
[01:28:58.500]                 }
[01:28:58.500]                 else {
[01:28:58.500]                   if (TRUE) {
[01:28:58.500]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:58.500]                     {
[01:28:58.500]                       inherits <- base::inherits
[01:28:58.500]                       invokeRestart <- base::invokeRestart
[01:28:58.500]                       is.null <- base::is.null
[01:28:58.500]                       muffled <- FALSE
[01:28:58.500]                       if (inherits(cond, "message")) {
[01:28:58.500]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:58.500]                         if (muffled) 
[01:28:58.500]                           invokeRestart("muffleMessage")
[01:28:58.500]                       }
[01:28:58.500]                       else if (inherits(cond, "warning")) {
[01:28:58.500]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:58.500]                         if (muffled) 
[01:28:58.500]                           invokeRestart("muffleWarning")
[01:28:58.500]                       }
[01:28:58.500]                       else if (inherits(cond, "condition")) {
[01:28:58.500]                         if (!is.null(pattern)) {
[01:28:58.500]                           computeRestarts <- base::computeRestarts
[01:28:58.500]                           grepl <- base::grepl
[01:28:58.500]                           restarts <- computeRestarts(cond)
[01:28:58.500]                           for (restart in restarts) {
[01:28:58.500]                             name <- restart$name
[01:28:58.500]                             if (is.null(name)) 
[01:28:58.500]                               next
[01:28:58.500]                             if (!grepl(pattern, name)) 
[01:28:58.500]                               next
[01:28:58.500]                             invokeRestart(restart)
[01:28:58.500]                             muffled <- TRUE
[01:28:58.500]                             break
[01:28:58.500]                           }
[01:28:58.500]                         }
[01:28:58.500]                       }
[01:28:58.500]                       invisible(muffled)
[01:28:58.500]                     }
[01:28:58.500]                     muffleCondition(cond, pattern = "^muffle")
[01:28:58.500]                   }
[01:28:58.500]                 }
[01:28:58.500]             }
[01:28:58.500]         }))
[01:28:58.500]     }, error = function(ex) {
[01:28:58.500]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:58.500]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:58.500]                 ...future.rng), started = ...future.startTime, 
[01:28:58.500]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:58.500]             version = "1.8"), class = "FutureResult")
[01:28:58.500]     }, finally = {
[01:28:58.500]         if (!identical(...future.workdir, getwd())) 
[01:28:58.500]             setwd(...future.workdir)
[01:28:58.500]         {
[01:28:58.500]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:58.500]                 ...future.oldOptions$nwarnings <- NULL
[01:28:58.500]             }
[01:28:58.500]             base::options(...future.oldOptions)
[01:28:58.500]             if (.Platform$OS.type == "windows") {
[01:28:58.500]                 old_names <- names(...future.oldEnvVars)
[01:28:58.500]                 envs <- base::Sys.getenv()
[01:28:58.500]                 names <- names(envs)
[01:28:58.500]                 common <- intersect(names, old_names)
[01:28:58.500]                 added <- setdiff(names, old_names)
[01:28:58.500]                 removed <- setdiff(old_names, names)
[01:28:58.500]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:58.500]                   envs[common]]
[01:28:58.500]                 NAMES <- toupper(changed)
[01:28:58.500]                 args <- list()
[01:28:58.500]                 for (kk in seq_along(NAMES)) {
[01:28:58.500]                   name <- changed[[kk]]
[01:28:58.500]                   NAME <- NAMES[[kk]]
[01:28:58.500]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:58.500]                     next
[01:28:58.500]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:58.500]                 }
[01:28:58.500]                 NAMES <- toupper(added)
[01:28:58.500]                 for (kk in seq_along(NAMES)) {
[01:28:58.500]                   name <- added[[kk]]
[01:28:58.500]                   NAME <- NAMES[[kk]]
[01:28:58.500]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:58.500]                     next
[01:28:58.500]                   args[[name]] <- ""
[01:28:58.500]                 }
[01:28:58.500]                 NAMES <- toupper(removed)
[01:28:58.500]                 for (kk in seq_along(NAMES)) {
[01:28:58.500]                   name <- removed[[kk]]
[01:28:58.500]                   NAME <- NAMES[[kk]]
[01:28:58.500]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:58.500]                     next
[01:28:58.500]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:58.500]                 }
[01:28:58.500]                 if (length(args) > 0) 
[01:28:58.500]                   base::do.call(base::Sys.setenv, args = args)
[01:28:58.500]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:58.500]             }
[01:28:58.500]             else {
[01:28:58.500]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:58.500]             }
[01:28:58.500]             {
[01:28:58.500]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:58.500]                   0L) {
[01:28:58.500]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:58.500]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:58.500]                   base::options(opts)
[01:28:58.500]                 }
[01:28:58.500]                 {
[01:28:58.500]                   {
[01:28:58.500]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:58.500]                     NULL
[01:28:58.500]                   }
[01:28:58.500]                   options(future.plan = NULL)
[01:28:58.500]                   if (is.na(NA_character_)) 
[01:28:58.500]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:58.500]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:58.500]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:58.500]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:58.500]                     envir = parent.frame()) 
[01:28:58.500]                   {
[01:28:58.500]                     if (is.function(workers)) 
[01:28:58.500]                       workers <- workers()
[01:28:58.500]                     workers <- structure(as.integer(workers), 
[01:28:58.500]                       class = class(workers))
[01:28:58.500]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:58.500]                       workers >= 1)
[01:28:58.500]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:58.500]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:58.500]                     }
[01:28:58.500]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:58.500]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:58.500]                       envir = envir)
[01:28:58.500]                     if (!future$lazy) 
[01:28:58.500]                       future <- run(future)
[01:28:58.500]                     invisible(future)
[01:28:58.500]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:58.500]                 }
[01:28:58.500]             }
[01:28:58.500]         }
[01:28:58.500]     })
[01:28:58.500]     if (TRUE) {
[01:28:58.500]         base::sink(type = "output", split = FALSE)
[01:28:58.500]         if (TRUE) {
[01:28:58.500]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:58.500]         }
[01:28:58.500]         else {
[01:28:58.500]             ...future.result["stdout"] <- base::list(NULL)
[01:28:58.500]         }
[01:28:58.500]         base::close(...future.stdout)
[01:28:58.500]         ...future.stdout <- NULL
[01:28:58.500]     }
[01:28:58.500]     ...future.result$conditions <- ...future.conditions
[01:28:58.500]     ...future.result$finished <- base::Sys.time()
[01:28:58.500]     ...future.result
[01:28:58.500] }
[01:28:58.507] MultisessionFuture started
[01:28:58.507] - Launch lazy future ... done
[01:28:58.507] run() for 'MultisessionFuture' ... done
[01:28:58.539] receiveMessageFromWorker() for ClusterFuture ...
[01:28:58.539] - Validating connection of MultisessionFuture
[01:28:58.540] - received message: FutureResult
[01:28:58.540] - Received FutureResult
[01:28:58.540] - Erased future from FutureRegistry
[01:28:58.540] result() for ClusterFuture ...
[01:28:58.541] - result already collected: FutureResult
[01:28:58.541] result() for ClusterFuture ... done
[01:28:58.541] signalConditions() ...
[01:28:58.541]  - include = 'immediateCondition'
[01:28:58.541]  - exclude = 
[01:28:58.541]  - resignal = FALSE
[01:28:58.542]  - Number of conditions: 1
[01:28:58.542] signalConditions() ... done
[01:28:58.542] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:58.542] A MultisessionFuture was resolved (result was not collected)
[01:28:58.542] getGlobalsAndPackages() ...
[01:28:58.543] Searching for globals...
[01:28:58.543] - globals found: [2] 'list', 'stop'
[01:28:58.544] Searching for globals ... DONE
[01:28:58.544] Resolving globals: FALSE
[01:28:58.544] 
[01:28:58.544] 
[01:28:58.545] getGlobalsAndPackages() ... DONE
[01:28:58.545] run() for 'Future' ...
[01:28:58.545] - state: 'created'
[01:28:58.545] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:58.560] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:58.560] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:58.560]   - Field: 'node'
[01:28:58.560]   - Field: 'label'
[01:28:58.561]   - Field: 'local'
[01:28:58.561]   - Field: 'owner'
[01:28:58.561]   - Field: 'envir'
[01:28:58.561]   - Field: 'workers'
[01:28:58.561]   - Field: 'packages'
[01:28:58.562]   - Field: 'gc'
[01:28:58.562]   - Field: 'conditions'
[01:28:58.562]   - Field: 'persistent'
[01:28:58.562]   - Field: 'expr'
[01:28:58.562]   - Field: 'uuid'
[01:28:58.563]   - Field: 'seed'
[01:28:58.563]   - Field: 'version'
[01:28:58.563]   - Field: 'result'
[01:28:58.563]   - Field: 'asynchronous'
[01:28:58.563]   - Field: 'calls'
[01:28:58.563]   - Field: 'globals'
[01:28:58.564]   - Field: 'stdout'
[01:28:58.564]   - Field: 'earlySignal'
[01:28:58.564]   - Field: 'lazy'
[01:28:58.564]   - Field: 'state'
[01:28:58.564] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:58.564] - Launch lazy future ...
[01:28:58.565] Packages needed by the future expression (n = 0): <none>
[01:28:58.565] Packages needed by future strategies (n = 0): <none>
[01:28:58.566] {
[01:28:58.566]     {
[01:28:58.566]         {
[01:28:58.566]             ...future.startTime <- base::Sys.time()
[01:28:58.566]             {
[01:28:58.566]                 {
[01:28:58.566]                   {
[01:28:58.566]                     {
[01:28:58.566]                       base::local({
[01:28:58.566]                         has_future <- base::requireNamespace("future", 
[01:28:58.566]                           quietly = TRUE)
[01:28:58.566]                         if (has_future) {
[01:28:58.566]                           ns <- base::getNamespace("future")
[01:28:58.566]                           version <- ns[[".package"]][["version"]]
[01:28:58.566]                           if (is.null(version)) 
[01:28:58.566]                             version <- utils::packageVersion("future")
[01:28:58.566]                         }
[01:28:58.566]                         else {
[01:28:58.566]                           version <- NULL
[01:28:58.566]                         }
[01:28:58.566]                         if (!has_future || version < "1.8.0") {
[01:28:58.566]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:58.566]                             "", base::R.version$version.string), 
[01:28:58.566]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:58.566]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:58.566]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:58.566]                               "release", "version")], collapse = " "), 
[01:28:58.566]                             hostname = base::Sys.info()[["nodename"]])
[01:28:58.566]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:58.566]                             info)
[01:28:58.566]                           info <- base::paste(info, collapse = "; ")
[01:28:58.566]                           if (!has_future) {
[01:28:58.566]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:58.566]                               info)
[01:28:58.566]                           }
[01:28:58.566]                           else {
[01:28:58.566]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:58.566]                               info, version)
[01:28:58.566]                           }
[01:28:58.566]                           base::stop(msg)
[01:28:58.566]                         }
[01:28:58.566]                       })
[01:28:58.566]                     }
[01:28:58.566]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:58.566]                     base::options(mc.cores = 1L)
[01:28:58.566]                   }
[01:28:58.566]                   options(future.plan = NULL)
[01:28:58.566]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:58.566]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:58.566]                 }
[01:28:58.566]                 ...future.workdir <- getwd()
[01:28:58.566]             }
[01:28:58.566]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:58.566]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:58.566]         }
[01:28:58.566]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:58.566]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:58.566]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:58.566]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:58.566]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:58.566]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:58.566]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:58.566]             base::names(...future.oldOptions))
[01:28:58.566]     }
[01:28:58.566]     if (FALSE) {
[01:28:58.566]     }
[01:28:58.566]     else {
[01:28:58.566]         if (TRUE) {
[01:28:58.566]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:58.566]                 open = "w")
[01:28:58.566]         }
[01:28:58.566]         else {
[01:28:58.566]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:58.566]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:58.566]         }
[01:28:58.566]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:58.566]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:58.566]             base::sink(type = "output", split = FALSE)
[01:28:58.566]             base::close(...future.stdout)
[01:28:58.566]         }, add = TRUE)
[01:28:58.566]     }
[01:28:58.566]     ...future.frame <- base::sys.nframe()
[01:28:58.566]     ...future.conditions <- base::list()
[01:28:58.566]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:58.566]     if (FALSE) {
[01:28:58.566]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:58.566]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:58.566]     }
[01:28:58.566]     ...future.result <- base::tryCatch({
[01:28:58.566]         base::withCallingHandlers({
[01:28:58.566]             ...future.value <- base::withVisible(base::local({
[01:28:58.566]                 ...future.makeSendCondition <- base::local({
[01:28:58.566]                   sendCondition <- NULL
[01:28:58.566]                   function(frame = 1L) {
[01:28:58.566]                     if (is.function(sendCondition)) 
[01:28:58.566]                       return(sendCondition)
[01:28:58.566]                     ns <- getNamespace("parallel")
[01:28:58.566]                     if (exists("sendData", mode = "function", 
[01:28:58.566]                       envir = ns)) {
[01:28:58.566]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:58.566]                         envir = ns)
[01:28:58.566]                       envir <- sys.frame(frame)
[01:28:58.566]                       master <- NULL
[01:28:58.566]                       while (!identical(envir, .GlobalEnv) && 
[01:28:58.566]                         !identical(envir, emptyenv())) {
[01:28:58.566]                         if (exists("master", mode = "list", envir = envir, 
[01:28:58.566]                           inherits = FALSE)) {
[01:28:58.566]                           master <- get("master", mode = "list", 
[01:28:58.566]                             envir = envir, inherits = FALSE)
[01:28:58.566]                           if (inherits(master, c("SOCKnode", 
[01:28:58.566]                             "SOCK0node"))) {
[01:28:58.566]                             sendCondition <<- function(cond) {
[01:28:58.566]                               data <- list(type = "VALUE", value = cond, 
[01:28:58.566]                                 success = TRUE)
[01:28:58.566]                               parallel_sendData(master, data)
[01:28:58.566]                             }
[01:28:58.566]                             return(sendCondition)
[01:28:58.566]                           }
[01:28:58.566]                         }
[01:28:58.566]                         frame <- frame + 1L
[01:28:58.566]                         envir <- sys.frame(frame)
[01:28:58.566]                       }
[01:28:58.566]                     }
[01:28:58.566]                     sendCondition <<- function(cond) NULL
[01:28:58.566]                   }
[01:28:58.566]                 })
[01:28:58.566]                 withCallingHandlers({
[01:28:58.566]                   list(a = 1, b = 42L, c = stop("Nah!"))
[01:28:58.566]                 }, immediateCondition = function(cond) {
[01:28:58.566]                   sendCondition <- ...future.makeSendCondition()
[01:28:58.566]                   sendCondition(cond)
[01:28:58.566]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:58.566]                   {
[01:28:58.566]                     inherits <- base::inherits
[01:28:58.566]                     invokeRestart <- base::invokeRestart
[01:28:58.566]                     is.null <- base::is.null
[01:28:58.566]                     muffled <- FALSE
[01:28:58.566]                     if (inherits(cond, "message")) {
[01:28:58.566]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:58.566]                       if (muffled) 
[01:28:58.566]                         invokeRestart("muffleMessage")
[01:28:58.566]                     }
[01:28:58.566]                     else if (inherits(cond, "warning")) {
[01:28:58.566]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:58.566]                       if (muffled) 
[01:28:58.566]                         invokeRestart("muffleWarning")
[01:28:58.566]                     }
[01:28:58.566]                     else if (inherits(cond, "condition")) {
[01:28:58.566]                       if (!is.null(pattern)) {
[01:28:58.566]                         computeRestarts <- base::computeRestarts
[01:28:58.566]                         grepl <- base::grepl
[01:28:58.566]                         restarts <- computeRestarts(cond)
[01:28:58.566]                         for (restart in restarts) {
[01:28:58.566]                           name <- restart$name
[01:28:58.566]                           if (is.null(name)) 
[01:28:58.566]                             next
[01:28:58.566]                           if (!grepl(pattern, name)) 
[01:28:58.566]                             next
[01:28:58.566]                           invokeRestart(restart)
[01:28:58.566]                           muffled <- TRUE
[01:28:58.566]                           break
[01:28:58.566]                         }
[01:28:58.566]                       }
[01:28:58.566]                     }
[01:28:58.566]                     invisible(muffled)
[01:28:58.566]                   }
[01:28:58.566]                   muffleCondition(cond)
[01:28:58.566]                 })
[01:28:58.566]             }))
[01:28:58.566]             future::FutureResult(value = ...future.value$value, 
[01:28:58.566]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:58.566]                   ...future.rng), globalenv = if (FALSE) 
[01:28:58.566]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:58.566]                     ...future.globalenv.names))
[01:28:58.566]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:58.566]         }, condition = base::local({
[01:28:58.566]             c <- base::c
[01:28:58.566]             inherits <- base::inherits
[01:28:58.566]             invokeRestart <- base::invokeRestart
[01:28:58.566]             length <- base::length
[01:28:58.566]             list <- base::list
[01:28:58.566]             seq.int <- base::seq.int
[01:28:58.566]             signalCondition <- base::signalCondition
[01:28:58.566]             sys.calls <- base::sys.calls
[01:28:58.566]             `[[` <- base::`[[`
[01:28:58.566]             `+` <- base::`+`
[01:28:58.566]             `<<-` <- base::`<<-`
[01:28:58.566]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:58.566]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:58.566]                   3L)]
[01:28:58.566]             }
[01:28:58.566]             function(cond) {
[01:28:58.566]                 is_error <- inherits(cond, "error")
[01:28:58.566]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:58.566]                   NULL)
[01:28:58.566]                 if (is_error) {
[01:28:58.566]                   sessionInformation <- function() {
[01:28:58.566]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:58.566]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:58.566]                       search = base::search(), system = base::Sys.info())
[01:28:58.566]                   }
[01:28:58.566]                   ...future.conditions[[length(...future.conditions) + 
[01:28:58.566]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:58.566]                     cond$call), session = sessionInformation(), 
[01:28:58.566]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:58.566]                   signalCondition(cond)
[01:28:58.566]                 }
[01:28:58.566]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:58.566]                 "immediateCondition"))) {
[01:28:58.566]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:58.566]                   ...future.conditions[[length(...future.conditions) + 
[01:28:58.566]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:58.566]                   if (TRUE && !signal) {
[01:28:58.566]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:58.566]                     {
[01:28:58.566]                       inherits <- base::inherits
[01:28:58.566]                       invokeRestart <- base::invokeRestart
[01:28:58.566]                       is.null <- base::is.null
[01:28:58.566]                       muffled <- FALSE
[01:28:58.566]                       if (inherits(cond, "message")) {
[01:28:58.566]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:58.566]                         if (muffled) 
[01:28:58.566]                           invokeRestart("muffleMessage")
[01:28:58.566]                       }
[01:28:58.566]                       else if (inherits(cond, "warning")) {
[01:28:58.566]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:58.566]                         if (muffled) 
[01:28:58.566]                           invokeRestart("muffleWarning")
[01:28:58.566]                       }
[01:28:58.566]                       else if (inherits(cond, "condition")) {
[01:28:58.566]                         if (!is.null(pattern)) {
[01:28:58.566]                           computeRestarts <- base::computeRestarts
[01:28:58.566]                           grepl <- base::grepl
[01:28:58.566]                           restarts <- computeRestarts(cond)
[01:28:58.566]                           for (restart in restarts) {
[01:28:58.566]                             name <- restart$name
[01:28:58.566]                             if (is.null(name)) 
[01:28:58.566]                               next
[01:28:58.566]                             if (!grepl(pattern, name)) 
[01:28:58.566]                               next
[01:28:58.566]                             invokeRestart(restart)
[01:28:58.566]                             muffled <- TRUE
[01:28:58.566]                             break
[01:28:58.566]                           }
[01:28:58.566]                         }
[01:28:58.566]                       }
[01:28:58.566]                       invisible(muffled)
[01:28:58.566]                     }
[01:28:58.566]                     muffleCondition(cond, pattern = "^muffle")
[01:28:58.566]                   }
[01:28:58.566]                 }
[01:28:58.566]                 else {
[01:28:58.566]                   if (TRUE) {
[01:28:58.566]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:58.566]                     {
[01:28:58.566]                       inherits <- base::inherits
[01:28:58.566]                       invokeRestart <- base::invokeRestart
[01:28:58.566]                       is.null <- base::is.null
[01:28:58.566]                       muffled <- FALSE
[01:28:58.566]                       if (inherits(cond, "message")) {
[01:28:58.566]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:58.566]                         if (muffled) 
[01:28:58.566]                           invokeRestart("muffleMessage")
[01:28:58.566]                       }
[01:28:58.566]                       else if (inherits(cond, "warning")) {
[01:28:58.566]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:58.566]                         if (muffled) 
[01:28:58.566]                           invokeRestart("muffleWarning")
[01:28:58.566]                       }
[01:28:58.566]                       else if (inherits(cond, "condition")) {
[01:28:58.566]                         if (!is.null(pattern)) {
[01:28:58.566]                           computeRestarts <- base::computeRestarts
[01:28:58.566]                           grepl <- base::grepl
[01:28:58.566]                           restarts <- computeRestarts(cond)
[01:28:58.566]                           for (restart in restarts) {
[01:28:58.566]                             name <- restart$name
[01:28:58.566]                             if (is.null(name)) 
[01:28:58.566]                               next
[01:28:58.566]                             if (!grepl(pattern, name)) 
[01:28:58.566]                               next
[01:28:58.566]                             invokeRestart(restart)
[01:28:58.566]                             muffled <- TRUE
[01:28:58.566]                             break
[01:28:58.566]                           }
[01:28:58.566]                         }
[01:28:58.566]                       }
[01:28:58.566]                       invisible(muffled)
[01:28:58.566]                     }
[01:28:58.566]                     muffleCondition(cond, pattern = "^muffle")
[01:28:58.566]                   }
[01:28:58.566]                 }
[01:28:58.566]             }
[01:28:58.566]         }))
[01:28:58.566]     }, error = function(ex) {
[01:28:58.566]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:58.566]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:58.566]                 ...future.rng), started = ...future.startTime, 
[01:28:58.566]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:58.566]             version = "1.8"), class = "FutureResult")
[01:28:58.566]     }, finally = {
[01:28:58.566]         if (!identical(...future.workdir, getwd())) 
[01:28:58.566]             setwd(...future.workdir)
[01:28:58.566]         {
[01:28:58.566]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:58.566]                 ...future.oldOptions$nwarnings <- NULL
[01:28:58.566]             }
[01:28:58.566]             base::options(...future.oldOptions)
[01:28:58.566]             if (.Platform$OS.type == "windows") {
[01:28:58.566]                 old_names <- names(...future.oldEnvVars)
[01:28:58.566]                 envs <- base::Sys.getenv()
[01:28:58.566]                 names <- names(envs)
[01:28:58.566]                 common <- intersect(names, old_names)
[01:28:58.566]                 added <- setdiff(names, old_names)
[01:28:58.566]                 removed <- setdiff(old_names, names)
[01:28:58.566]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:58.566]                   envs[common]]
[01:28:58.566]                 NAMES <- toupper(changed)
[01:28:58.566]                 args <- list()
[01:28:58.566]                 for (kk in seq_along(NAMES)) {
[01:28:58.566]                   name <- changed[[kk]]
[01:28:58.566]                   NAME <- NAMES[[kk]]
[01:28:58.566]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:58.566]                     next
[01:28:58.566]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:58.566]                 }
[01:28:58.566]                 NAMES <- toupper(added)
[01:28:58.566]                 for (kk in seq_along(NAMES)) {
[01:28:58.566]                   name <- added[[kk]]
[01:28:58.566]                   NAME <- NAMES[[kk]]
[01:28:58.566]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:58.566]                     next
[01:28:58.566]                   args[[name]] <- ""
[01:28:58.566]                 }
[01:28:58.566]                 NAMES <- toupper(removed)
[01:28:58.566]                 for (kk in seq_along(NAMES)) {
[01:28:58.566]                   name <- removed[[kk]]
[01:28:58.566]                   NAME <- NAMES[[kk]]
[01:28:58.566]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:58.566]                     next
[01:28:58.566]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:58.566]                 }
[01:28:58.566]                 if (length(args) > 0) 
[01:28:58.566]                   base::do.call(base::Sys.setenv, args = args)
[01:28:58.566]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:58.566]             }
[01:28:58.566]             else {
[01:28:58.566]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:58.566]             }
[01:28:58.566]             {
[01:28:58.566]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:58.566]                   0L) {
[01:28:58.566]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:58.566]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:58.566]                   base::options(opts)
[01:28:58.566]                 }
[01:28:58.566]                 {
[01:28:58.566]                   {
[01:28:58.566]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:58.566]                     NULL
[01:28:58.566]                   }
[01:28:58.566]                   options(future.plan = NULL)
[01:28:58.566]                   if (is.na(NA_character_)) 
[01:28:58.566]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:58.566]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:58.566]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:58.566]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:58.566]                     envir = parent.frame()) 
[01:28:58.566]                   {
[01:28:58.566]                     if (is.function(workers)) 
[01:28:58.566]                       workers <- workers()
[01:28:58.566]                     workers <- structure(as.integer(workers), 
[01:28:58.566]                       class = class(workers))
[01:28:58.566]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:58.566]                       workers >= 1)
[01:28:58.566]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:58.566]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:58.566]                     }
[01:28:58.566]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:58.566]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:58.566]                       envir = envir)
[01:28:58.566]                     if (!future$lazy) 
[01:28:58.566]                       future <- run(future)
[01:28:58.566]                     invisible(future)
[01:28:58.566]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:58.566]                 }
[01:28:58.566]             }
[01:28:58.566]         }
[01:28:58.566]     })
[01:28:58.566]     if (TRUE) {
[01:28:58.566]         base::sink(type = "output", split = FALSE)
[01:28:58.566]         if (TRUE) {
[01:28:58.566]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:58.566]         }
[01:28:58.566]         else {
[01:28:58.566]             ...future.result["stdout"] <- base::list(NULL)
[01:28:58.566]         }
[01:28:58.566]         base::close(...future.stdout)
[01:28:58.566]         ...future.stdout <- NULL
[01:28:58.566]     }
[01:28:58.566]     ...future.result$conditions <- ...future.conditions
[01:28:58.566]     ...future.result$finished <- base::Sys.time()
[01:28:58.566]     ...future.result
[01:28:58.566] }
[01:28:58.572] MultisessionFuture started
[01:28:58.572] - Launch lazy future ... done
[01:28:58.572] run() for 'MultisessionFuture' ... done
[01:28:58.596] receiveMessageFromWorker() for ClusterFuture ...
[01:28:58.596] - Validating connection of MultisessionFuture
[01:28:58.596] - received message: FutureResult
[01:28:58.597] - Received FutureResult
[01:28:58.597] - Erased future from FutureRegistry
[01:28:58.597] result() for ClusterFuture ...
[01:28:58.597] - result already collected: FutureResult
[01:28:58.597] result() for ClusterFuture ... done
[01:28:58.598] signalConditions() ...
[01:28:58.598]  - include = 'immediateCondition'
[01:28:58.598]  - exclude = 
[01:28:58.598]  - resignal = FALSE
[01:28:58.598]  - Number of conditions: 1
[01:28:58.598] signalConditions() ... done
[01:28:58.599] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:58.599] A MultisessionFuture was resolved (result was not collected)
- result = FALSE, recursive = TRUE ... DONE
- result = FALSE, recursive = -1 ...
[01:28:58.599] getGlobalsAndPackages() ...
[01:28:58.599] Searching for globals...
[01:28:58.601] - globals found: [3] '{', 'Sys.sleep', 'list'
[01:28:58.601] Searching for globals ... DONE
[01:28:58.601] Resolving globals: FALSE
[01:28:58.601] 
[01:28:58.602] 
[01:28:58.602] getGlobalsAndPackages() ... DONE
[01:28:58.602] run() for 'Future' ...
[01:28:58.602] - state: 'created'
[01:28:58.603] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:58.617] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:58.617] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:58.617]   - Field: 'node'
[01:28:58.618]   - Field: 'label'
[01:28:58.618]   - Field: 'local'
[01:28:58.618]   - Field: 'owner'
[01:28:58.618]   - Field: 'envir'
[01:28:58.618]   - Field: 'workers'
[01:28:58.619]   - Field: 'packages'
[01:28:58.619]   - Field: 'gc'
[01:28:58.619]   - Field: 'conditions'
[01:28:58.619]   - Field: 'persistent'
[01:28:58.619]   - Field: 'expr'
[01:28:58.619]   - Field: 'uuid'
[01:28:58.620]   - Field: 'seed'
[01:28:58.620]   - Field: 'version'
[01:28:58.620]   - Field: 'result'
[01:28:58.620]   - Field: 'asynchronous'
[01:28:58.620]   - Field: 'calls'
[01:28:58.620]   - Field: 'globals'
[01:28:58.621]   - Field: 'stdout'
[01:28:58.621]   - Field: 'earlySignal'
[01:28:58.621]   - Field: 'lazy'
[01:28:58.621]   - Field: 'state'
[01:28:58.621] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:58.622] - Launch lazy future ...
[01:28:58.622] Packages needed by the future expression (n = 0): <none>
[01:28:58.622] Packages needed by future strategies (n = 0): <none>
[01:28:58.623] {
[01:28:58.623]     {
[01:28:58.623]         {
[01:28:58.623]             ...future.startTime <- base::Sys.time()
[01:28:58.623]             {
[01:28:58.623]                 {
[01:28:58.623]                   {
[01:28:58.623]                     {
[01:28:58.623]                       base::local({
[01:28:58.623]                         has_future <- base::requireNamespace("future", 
[01:28:58.623]                           quietly = TRUE)
[01:28:58.623]                         if (has_future) {
[01:28:58.623]                           ns <- base::getNamespace("future")
[01:28:58.623]                           version <- ns[[".package"]][["version"]]
[01:28:58.623]                           if (is.null(version)) 
[01:28:58.623]                             version <- utils::packageVersion("future")
[01:28:58.623]                         }
[01:28:58.623]                         else {
[01:28:58.623]                           version <- NULL
[01:28:58.623]                         }
[01:28:58.623]                         if (!has_future || version < "1.8.0") {
[01:28:58.623]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:58.623]                             "", base::R.version$version.string), 
[01:28:58.623]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:58.623]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:58.623]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:58.623]                               "release", "version")], collapse = " "), 
[01:28:58.623]                             hostname = base::Sys.info()[["nodename"]])
[01:28:58.623]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:58.623]                             info)
[01:28:58.623]                           info <- base::paste(info, collapse = "; ")
[01:28:58.623]                           if (!has_future) {
[01:28:58.623]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:58.623]                               info)
[01:28:58.623]                           }
[01:28:58.623]                           else {
[01:28:58.623]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:58.623]                               info, version)
[01:28:58.623]                           }
[01:28:58.623]                           base::stop(msg)
[01:28:58.623]                         }
[01:28:58.623]                       })
[01:28:58.623]                     }
[01:28:58.623]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:58.623]                     base::options(mc.cores = 1L)
[01:28:58.623]                   }
[01:28:58.623]                   options(future.plan = NULL)
[01:28:58.623]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:58.623]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:58.623]                 }
[01:28:58.623]                 ...future.workdir <- getwd()
[01:28:58.623]             }
[01:28:58.623]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:58.623]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:58.623]         }
[01:28:58.623]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:58.623]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:58.623]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:58.623]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:58.623]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:58.623]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:58.623]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:58.623]             base::names(...future.oldOptions))
[01:28:58.623]     }
[01:28:58.623]     if (FALSE) {
[01:28:58.623]     }
[01:28:58.623]     else {
[01:28:58.623]         if (TRUE) {
[01:28:58.623]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:58.623]                 open = "w")
[01:28:58.623]         }
[01:28:58.623]         else {
[01:28:58.623]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:58.623]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:58.623]         }
[01:28:58.623]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:58.623]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:58.623]             base::sink(type = "output", split = FALSE)
[01:28:58.623]             base::close(...future.stdout)
[01:28:58.623]         }, add = TRUE)
[01:28:58.623]     }
[01:28:58.623]     ...future.frame <- base::sys.nframe()
[01:28:58.623]     ...future.conditions <- base::list()
[01:28:58.623]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:58.623]     if (FALSE) {
[01:28:58.623]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:58.623]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:58.623]     }
[01:28:58.623]     ...future.result <- base::tryCatch({
[01:28:58.623]         base::withCallingHandlers({
[01:28:58.623]             ...future.value <- base::withVisible(base::local({
[01:28:58.623]                 ...future.makeSendCondition <- base::local({
[01:28:58.623]                   sendCondition <- NULL
[01:28:58.623]                   function(frame = 1L) {
[01:28:58.623]                     if (is.function(sendCondition)) 
[01:28:58.623]                       return(sendCondition)
[01:28:58.623]                     ns <- getNamespace("parallel")
[01:28:58.623]                     if (exists("sendData", mode = "function", 
[01:28:58.623]                       envir = ns)) {
[01:28:58.623]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:58.623]                         envir = ns)
[01:28:58.623]                       envir <- sys.frame(frame)
[01:28:58.623]                       master <- NULL
[01:28:58.623]                       while (!identical(envir, .GlobalEnv) && 
[01:28:58.623]                         !identical(envir, emptyenv())) {
[01:28:58.623]                         if (exists("master", mode = "list", envir = envir, 
[01:28:58.623]                           inherits = FALSE)) {
[01:28:58.623]                           master <- get("master", mode = "list", 
[01:28:58.623]                             envir = envir, inherits = FALSE)
[01:28:58.623]                           if (inherits(master, c("SOCKnode", 
[01:28:58.623]                             "SOCK0node"))) {
[01:28:58.623]                             sendCondition <<- function(cond) {
[01:28:58.623]                               data <- list(type = "VALUE", value = cond, 
[01:28:58.623]                                 success = TRUE)
[01:28:58.623]                               parallel_sendData(master, data)
[01:28:58.623]                             }
[01:28:58.623]                             return(sendCondition)
[01:28:58.623]                           }
[01:28:58.623]                         }
[01:28:58.623]                         frame <- frame + 1L
[01:28:58.623]                         envir <- sys.frame(frame)
[01:28:58.623]                       }
[01:28:58.623]                     }
[01:28:58.623]                     sendCondition <<- function(cond) NULL
[01:28:58.623]                   }
[01:28:58.623]                 })
[01:28:58.623]                 withCallingHandlers({
[01:28:58.623]                   {
[01:28:58.623]                     Sys.sleep(0.5)
[01:28:58.623]                     list(a = 1, b = 42L)
[01:28:58.623]                   }
[01:28:58.623]                 }, immediateCondition = function(cond) {
[01:28:58.623]                   sendCondition <- ...future.makeSendCondition()
[01:28:58.623]                   sendCondition(cond)
[01:28:58.623]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:58.623]                   {
[01:28:58.623]                     inherits <- base::inherits
[01:28:58.623]                     invokeRestart <- base::invokeRestart
[01:28:58.623]                     is.null <- base::is.null
[01:28:58.623]                     muffled <- FALSE
[01:28:58.623]                     if (inherits(cond, "message")) {
[01:28:58.623]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:58.623]                       if (muffled) 
[01:28:58.623]                         invokeRestart("muffleMessage")
[01:28:58.623]                     }
[01:28:58.623]                     else if (inherits(cond, "warning")) {
[01:28:58.623]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:58.623]                       if (muffled) 
[01:28:58.623]                         invokeRestart("muffleWarning")
[01:28:58.623]                     }
[01:28:58.623]                     else if (inherits(cond, "condition")) {
[01:28:58.623]                       if (!is.null(pattern)) {
[01:28:58.623]                         computeRestarts <- base::computeRestarts
[01:28:58.623]                         grepl <- base::grepl
[01:28:58.623]                         restarts <- computeRestarts(cond)
[01:28:58.623]                         for (restart in restarts) {
[01:28:58.623]                           name <- restart$name
[01:28:58.623]                           if (is.null(name)) 
[01:28:58.623]                             next
[01:28:58.623]                           if (!grepl(pattern, name)) 
[01:28:58.623]                             next
[01:28:58.623]                           invokeRestart(restart)
[01:28:58.623]                           muffled <- TRUE
[01:28:58.623]                           break
[01:28:58.623]                         }
[01:28:58.623]                       }
[01:28:58.623]                     }
[01:28:58.623]                     invisible(muffled)
[01:28:58.623]                   }
[01:28:58.623]                   muffleCondition(cond)
[01:28:58.623]                 })
[01:28:58.623]             }))
[01:28:58.623]             future::FutureResult(value = ...future.value$value, 
[01:28:58.623]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:58.623]                   ...future.rng), globalenv = if (FALSE) 
[01:28:58.623]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:58.623]                     ...future.globalenv.names))
[01:28:58.623]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:58.623]         }, condition = base::local({
[01:28:58.623]             c <- base::c
[01:28:58.623]             inherits <- base::inherits
[01:28:58.623]             invokeRestart <- base::invokeRestart
[01:28:58.623]             length <- base::length
[01:28:58.623]             list <- base::list
[01:28:58.623]             seq.int <- base::seq.int
[01:28:58.623]             signalCondition <- base::signalCondition
[01:28:58.623]             sys.calls <- base::sys.calls
[01:28:58.623]             `[[` <- base::`[[`
[01:28:58.623]             `+` <- base::`+`
[01:28:58.623]             `<<-` <- base::`<<-`
[01:28:58.623]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:58.623]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:58.623]                   3L)]
[01:28:58.623]             }
[01:28:58.623]             function(cond) {
[01:28:58.623]                 is_error <- inherits(cond, "error")
[01:28:58.623]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:58.623]                   NULL)
[01:28:58.623]                 if (is_error) {
[01:28:58.623]                   sessionInformation <- function() {
[01:28:58.623]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:58.623]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:58.623]                       search = base::search(), system = base::Sys.info())
[01:28:58.623]                   }
[01:28:58.623]                   ...future.conditions[[length(...future.conditions) + 
[01:28:58.623]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:58.623]                     cond$call), session = sessionInformation(), 
[01:28:58.623]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:58.623]                   signalCondition(cond)
[01:28:58.623]                 }
[01:28:58.623]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:58.623]                 "immediateCondition"))) {
[01:28:58.623]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:58.623]                   ...future.conditions[[length(...future.conditions) + 
[01:28:58.623]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:58.623]                   if (TRUE && !signal) {
[01:28:58.623]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:58.623]                     {
[01:28:58.623]                       inherits <- base::inherits
[01:28:58.623]                       invokeRestart <- base::invokeRestart
[01:28:58.623]                       is.null <- base::is.null
[01:28:58.623]                       muffled <- FALSE
[01:28:58.623]                       if (inherits(cond, "message")) {
[01:28:58.623]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:58.623]                         if (muffled) 
[01:28:58.623]                           invokeRestart("muffleMessage")
[01:28:58.623]                       }
[01:28:58.623]                       else if (inherits(cond, "warning")) {
[01:28:58.623]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:58.623]                         if (muffled) 
[01:28:58.623]                           invokeRestart("muffleWarning")
[01:28:58.623]                       }
[01:28:58.623]                       else if (inherits(cond, "condition")) {
[01:28:58.623]                         if (!is.null(pattern)) {
[01:28:58.623]                           computeRestarts <- base::computeRestarts
[01:28:58.623]                           grepl <- base::grepl
[01:28:58.623]                           restarts <- computeRestarts(cond)
[01:28:58.623]                           for (restart in restarts) {
[01:28:58.623]                             name <- restart$name
[01:28:58.623]                             if (is.null(name)) 
[01:28:58.623]                               next
[01:28:58.623]                             if (!grepl(pattern, name)) 
[01:28:58.623]                               next
[01:28:58.623]                             invokeRestart(restart)
[01:28:58.623]                             muffled <- TRUE
[01:28:58.623]                             break
[01:28:58.623]                           }
[01:28:58.623]                         }
[01:28:58.623]                       }
[01:28:58.623]                       invisible(muffled)
[01:28:58.623]                     }
[01:28:58.623]                     muffleCondition(cond, pattern = "^muffle")
[01:28:58.623]                   }
[01:28:58.623]                 }
[01:28:58.623]                 else {
[01:28:58.623]                   if (TRUE) {
[01:28:58.623]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:58.623]                     {
[01:28:58.623]                       inherits <- base::inherits
[01:28:58.623]                       invokeRestart <- base::invokeRestart
[01:28:58.623]                       is.null <- base::is.null
[01:28:58.623]                       muffled <- FALSE
[01:28:58.623]                       if (inherits(cond, "message")) {
[01:28:58.623]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:58.623]                         if (muffled) 
[01:28:58.623]                           invokeRestart("muffleMessage")
[01:28:58.623]                       }
[01:28:58.623]                       else if (inherits(cond, "warning")) {
[01:28:58.623]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:58.623]                         if (muffled) 
[01:28:58.623]                           invokeRestart("muffleWarning")
[01:28:58.623]                       }
[01:28:58.623]                       else if (inherits(cond, "condition")) {
[01:28:58.623]                         if (!is.null(pattern)) {
[01:28:58.623]                           computeRestarts <- base::computeRestarts
[01:28:58.623]                           grepl <- base::grepl
[01:28:58.623]                           restarts <- computeRestarts(cond)
[01:28:58.623]                           for (restart in restarts) {
[01:28:58.623]                             name <- restart$name
[01:28:58.623]                             if (is.null(name)) 
[01:28:58.623]                               next
[01:28:58.623]                             if (!grepl(pattern, name)) 
[01:28:58.623]                               next
[01:28:58.623]                             invokeRestart(restart)
[01:28:58.623]                             muffled <- TRUE
[01:28:58.623]                             break
[01:28:58.623]                           }
[01:28:58.623]                         }
[01:28:58.623]                       }
[01:28:58.623]                       invisible(muffled)
[01:28:58.623]                     }
[01:28:58.623]                     muffleCondition(cond, pattern = "^muffle")
[01:28:58.623]                   }
[01:28:58.623]                 }
[01:28:58.623]             }
[01:28:58.623]         }))
[01:28:58.623]     }, error = function(ex) {
[01:28:58.623]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:58.623]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:58.623]                 ...future.rng), started = ...future.startTime, 
[01:28:58.623]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:58.623]             version = "1.8"), class = "FutureResult")
[01:28:58.623]     }, finally = {
[01:28:58.623]         if (!identical(...future.workdir, getwd())) 
[01:28:58.623]             setwd(...future.workdir)
[01:28:58.623]         {
[01:28:58.623]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:58.623]                 ...future.oldOptions$nwarnings <- NULL
[01:28:58.623]             }
[01:28:58.623]             base::options(...future.oldOptions)
[01:28:58.623]             if (.Platform$OS.type == "windows") {
[01:28:58.623]                 old_names <- names(...future.oldEnvVars)
[01:28:58.623]                 envs <- base::Sys.getenv()
[01:28:58.623]                 names <- names(envs)
[01:28:58.623]                 common <- intersect(names, old_names)
[01:28:58.623]                 added <- setdiff(names, old_names)
[01:28:58.623]                 removed <- setdiff(old_names, names)
[01:28:58.623]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:58.623]                   envs[common]]
[01:28:58.623]                 NAMES <- toupper(changed)
[01:28:58.623]                 args <- list()
[01:28:58.623]                 for (kk in seq_along(NAMES)) {
[01:28:58.623]                   name <- changed[[kk]]
[01:28:58.623]                   NAME <- NAMES[[kk]]
[01:28:58.623]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:58.623]                     next
[01:28:58.623]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:58.623]                 }
[01:28:58.623]                 NAMES <- toupper(added)
[01:28:58.623]                 for (kk in seq_along(NAMES)) {
[01:28:58.623]                   name <- added[[kk]]
[01:28:58.623]                   NAME <- NAMES[[kk]]
[01:28:58.623]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:58.623]                     next
[01:28:58.623]                   args[[name]] <- ""
[01:28:58.623]                 }
[01:28:58.623]                 NAMES <- toupper(removed)
[01:28:58.623]                 for (kk in seq_along(NAMES)) {
[01:28:58.623]                   name <- removed[[kk]]
[01:28:58.623]                   NAME <- NAMES[[kk]]
[01:28:58.623]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:58.623]                     next
[01:28:58.623]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:58.623]                 }
[01:28:58.623]                 if (length(args) > 0) 
[01:28:58.623]                   base::do.call(base::Sys.setenv, args = args)
[01:28:58.623]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:58.623]             }
[01:28:58.623]             else {
[01:28:58.623]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:58.623]             }
[01:28:58.623]             {
[01:28:58.623]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:58.623]                   0L) {
[01:28:58.623]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:58.623]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:58.623]                   base::options(opts)
[01:28:58.623]                 }
[01:28:58.623]                 {
[01:28:58.623]                   {
[01:28:58.623]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:58.623]                     NULL
[01:28:58.623]                   }
[01:28:58.623]                   options(future.plan = NULL)
[01:28:58.623]                   if (is.na(NA_character_)) 
[01:28:58.623]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:58.623]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:58.623]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:58.623]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:58.623]                     envir = parent.frame()) 
[01:28:58.623]                   {
[01:28:58.623]                     if (is.function(workers)) 
[01:28:58.623]                       workers <- workers()
[01:28:58.623]                     workers <- structure(as.integer(workers), 
[01:28:58.623]                       class = class(workers))
[01:28:58.623]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:58.623]                       workers >= 1)
[01:28:58.623]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:58.623]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:58.623]                     }
[01:28:58.623]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:58.623]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:58.623]                       envir = envir)
[01:28:58.623]                     if (!future$lazy) 
[01:28:58.623]                       future <- run(future)
[01:28:58.623]                     invisible(future)
[01:28:58.623]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:58.623]                 }
[01:28:58.623]             }
[01:28:58.623]         }
[01:28:58.623]     })
[01:28:58.623]     if (TRUE) {
[01:28:58.623]         base::sink(type = "output", split = FALSE)
[01:28:58.623]         if (TRUE) {
[01:28:58.623]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:58.623]         }
[01:28:58.623]         else {
[01:28:58.623]             ...future.result["stdout"] <- base::list(NULL)
[01:28:58.623]         }
[01:28:58.623]         base::close(...future.stdout)
[01:28:58.623]         ...future.stdout <- NULL
[01:28:58.623]     }
[01:28:58.623]     ...future.result$conditions <- ...future.conditions
[01:28:58.623]     ...future.result$finished <- base::Sys.time()
[01:28:58.623]     ...future.result
[01:28:58.623] }
[01:28:58.628] MultisessionFuture started
[01:28:58.629] - Launch lazy future ... done
[01:28:58.629] run() for 'MultisessionFuture' ... done
[01:28:58.629] getGlobalsAndPackages() ...
[01:28:58.629] Searching for globals...
[01:28:58.631] - globals found: [3] '{', 'Sys.sleep', 'list'
[01:28:58.631] Searching for globals ... DONE
[01:28:58.631] Resolving globals: FALSE
[01:28:58.631] 
[01:28:58.632] 
[01:28:58.632] getGlobalsAndPackages() ... DONE
- w/ exception ...
[01:28:58.632] getGlobalsAndPackages() ...
[01:28:58.632] Searching for globals...
[01:28:58.633] - globals found: [2] 'list', 'stop'
[01:28:58.633] Searching for globals ... DONE
[01:28:58.633] Resolving globals: FALSE
[01:28:58.634] 
[01:28:58.634] 
[01:28:58.634] getGlobalsAndPackages() ... DONE
[01:28:58.634] run() for 'Future' ...
[01:28:58.635] - state: 'created'
[01:28:58.635] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:58.649] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:58.649] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:58.650]   - Field: 'node'
[01:28:58.650]   - Field: 'label'
[01:28:58.650]   - Field: 'local'
[01:28:58.650]   - Field: 'owner'
[01:28:58.650]   - Field: 'envir'
[01:28:58.651]   - Field: 'workers'
[01:28:58.651]   - Field: 'packages'
[01:28:58.651]   - Field: 'gc'
[01:28:58.652]   - Field: 'conditions'
[01:28:58.652]   - Field: 'persistent'
[01:28:58.652]   - Field: 'expr'
[01:28:58.652]   - Field: 'uuid'
[01:28:58.653]   - Field: 'seed'
[01:28:58.653]   - Field: 'version'
[01:28:58.653]   - Field: 'result'
[01:28:58.653]   - Field: 'asynchronous'
[01:28:58.653]   - Field: 'calls'
[01:28:58.653]   - Field: 'globals'
[01:28:58.654]   - Field: 'stdout'
[01:28:58.654]   - Field: 'earlySignal'
[01:28:58.654]   - Field: 'lazy'
[01:28:58.654]   - Field: 'state'
[01:28:58.654] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:58.654] - Launch lazy future ...
[01:28:58.655] Packages needed by the future expression (n = 0): <none>
[01:28:58.655] Packages needed by future strategies (n = 0): <none>
[01:28:58.656] {
[01:28:58.656]     {
[01:28:58.656]         {
[01:28:58.656]             ...future.startTime <- base::Sys.time()
[01:28:58.656]             {
[01:28:58.656]                 {
[01:28:58.656]                   {
[01:28:58.656]                     {
[01:28:58.656]                       base::local({
[01:28:58.656]                         has_future <- base::requireNamespace("future", 
[01:28:58.656]                           quietly = TRUE)
[01:28:58.656]                         if (has_future) {
[01:28:58.656]                           ns <- base::getNamespace("future")
[01:28:58.656]                           version <- ns[[".package"]][["version"]]
[01:28:58.656]                           if (is.null(version)) 
[01:28:58.656]                             version <- utils::packageVersion("future")
[01:28:58.656]                         }
[01:28:58.656]                         else {
[01:28:58.656]                           version <- NULL
[01:28:58.656]                         }
[01:28:58.656]                         if (!has_future || version < "1.8.0") {
[01:28:58.656]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:58.656]                             "", base::R.version$version.string), 
[01:28:58.656]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:58.656]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:58.656]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:58.656]                               "release", "version")], collapse = " "), 
[01:28:58.656]                             hostname = base::Sys.info()[["nodename"]])
[01:28:58.656]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:58.656]                             info)
[01:28:58.656]                           info <- base::paste(info, collapse = "; ")
[01:28:58.656]                           if (!has_future) {
[01:28:58.656]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:58.656]                               info)
[01:28:58.656]                           }
[01:28:58.656]                           else {
[01:28:58.656]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:58.656]                               info, version)
[01:28:58.656]                           }
[01:28:58.656]                           base::stop(msg)
[01:28:58.656]                         }
[01:28:58.656]                       })
[01:28:58.656]                     }
[01:28:58.656]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:58.656]                     base::options(mc.cores = 1L)
[01:28:58.656]                   }
[01:28:58.656]                   options(future.plan = NULL)
[01:28:58.656]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:58.656]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:58.656]                 }
[01:28:58.656]                 ...future.workdir <- getwd()
[01:28:58.656]             }
[01:28:58.656]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:58.656]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:58.656]         }
[01:28:58.656]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:58.656]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:58.656]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:58.656]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:58.656]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:58.656]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:58.656]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:58.656]             base::names(...future.oldOptions))
[01:28:58.656]     }
[01:28:58.656]     if (FALSE) {
[01:28:58.656]     }
[01:28:58.656]     else {
[01:28:58.656]         if (TRUE) {
[01:28:58.656]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:58.656]                 open = "w")
[01:28:58.656]         }
[01:28:58.656]         else {
[01:28:58.656]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:58.656]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:58.656]         }
[01:28:58.656]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:58.656]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:58.656]             base::sink(type = "output", split = FALSE)
[01:28:58.656]             base::close(...future.stdout)
[01:28:58.656]         }, add = TRUE)
[01:28:58.656]     }
[01:28:58.656]     ...future.frame <- base::sys.nframe()
[01:28:58.656]     ...future.conditions <- base::list()
[01:28:58.656]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:58.656]     if (FALSE) {
[01:28:58.656]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:58.656]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:58.656]     }
[01:28:58.656]     ...future.result <- base::tryCatch({
[01:28:58.656]         base::withCallingHandlers({
[01:28:58.656]             ...future.value <- base::withVisible(base::local({
[01:28:58.656]                 ...future.makeSendCondition <- base::local({
[01:28:58.656]                   sendCondition <- NULL
[01:28:58.656]                   function(frame = 1L) {
[01:28:58.656]                     if (is.function(sendCondition)) 
[01:28:58.656]                       return(sendCondition)
[01:28:58.656]                     ns <- getNamespace("parallel")
[01:28:58.656]                     if (exists("sendData", mode = "function", 
[01:28:58.656]                       envir = ns)) {
[01:28:58.656]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:58.656]                         envir = ns)
[01:28:58.656]                       envir <- sys.frame(frame)
[01:28:58.656]                       master <- NULL
[01:28:58.656]                       while (!identical(envir, .GlobalEnv) && 
[01:28:58.656]                         !identical(envir, emptyenv())) {
[01:28:58.656]                         if (exists("master", mode = "list", envir = envir, 
[01:28:58.656]                           inherits = FALSE)) {
[01:28:58.656]                           master <- get("master", mode = "list", 
[01:28:58.656]                             envir = envir, inherits = FALSE)
[01:28:58.656]                           if (inherits(master, c("SOCKnode", 
[01:28:58.656]                             "SOCK0node"))) {
[01:28:58.656]                             sendCondition <<- function(cond) {
[01:28:58.656]                               data <- list(type = "VALUE", value = cond, 
[01:28:58.656]                                 success = TRUE)
[01:28:58.656]                               parallel_sendData(master, data)
[01:28:58.656]                             }
[01:28:58.656]                             return(sendCondition)
[01:28:58.656]                           }
[01:28:58.656]                         }
[01:28:58.656]                         frame <- frame + 1L
[01:28:58.656]                         envir <- sys.frame(frame)
[01:28:58.656]                       }
[01:28:58.656]                     }
[01:28:58.656]                     sendCondition <<- function(cond) NULL
[01:28:58.656]                   }
[01:28:58.656]                 })
[01:28:58.656]                 withCallingHandlers({
[01:28:58.656]                   list(a = 1, b = 42L, c = stop("Nah!"))
[01:28:58.656]                 }, immediateCondition = function(cond) {
[01:28:58.656]                   sendCondition <- ...future.makeSendCondition()
[01:28:58.656]                   sendCondition(cond)
[01:28:58.656]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:58.656]                   {
[01:28:58.656]                     inherits <- base::inherits
[01:28:58.656]                     invokeRestart <- base::invokeRestart
[01:28:58.656]                     is.null <- base::is.null
[01:28:58.656]                     muffled <- FALSE
[01:28:58.656]                     if (inherits(cond, "message")) {
[01:28:58.656]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:58.656]                       if (muffled) 
[01:28:58.656]                         invokeRestart("muffleMessage")
[01:28:58.656]                     }
[01:28:58.656]                     else if (inherits(cond, "warning")) {
[01:28:58.656]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:58.656]                       if (muffled) 
[01:28:58.656]                         invokeRestart("muffleWarning")
[01:28:58.656]                     }
[01:28:58.656]                     else if (inherits(cond, "condition")) {
[01:28:58.656]                       if (!is.null(pattern)) {
[01:28:58.656]                         computeRestarts <- base::computeRestarts
[01:28:58.656]                         grepl <- base::grepl
[01:28:58.656]                         restarts <- computeRestarts(cond)
[01:28:58.656]                         for (restart in restarts) {
[01:28:58.656]                           name <- restart$name
[01:28:58.656]                           if (is.null(name)) 
[01:28:58.656]                             next
[01:28:58.656]                           if (!grepl(pattern, name)) 
[01:28:58.656]                             next
[01:28:58.656]                           invokeRestart(restart)
[01:28:58.656]                           muffled <- TRUE
[01:28:58.656]                           break
[01:28:58.656]                         }
[01:28:58.656]                       }
[01:28:58.656]                     }
[01:28:58.656]                     invisible(muffled)
[01:28:58.656]                   }
[01:28:58.656]                   muffleCondition(cond)
[01:28:58.656]                 })
[01:28:58.656]             }))
[01:28:58.656]             future::FutureResult(value = ...future.value$value, 
[01:28:58.656]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:58.656]                   ...future.rng), globalenv = if (FALSE) 
[01:28:58.656]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:58.656]                     ...future.globalenv.names))
[01:28:58.656]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:58.656]         }, condition = base::local({
[01:28:58.656]             c <- base::c
[01:28:58.656]             inherits <- base::inherits
[01:28:58.656]             invokeRestart <- base::invokeRestart
[01:28:58.656]             length <- base::length
[01:28:58.656]             list <- base::list
[01:28:58.656]             seq.int <- base::seq.int
[01:28:58.656]             signalCondition <- base::signalCondition
[01:28:58.656]             sys.calls <- base::sys.calls
[01:28:58.656]             `[[` <- base::`[[`
[01:28:58.656]             `+` <- base::`+`
[01:28:58.656]             `<<-` <- base::`<<-`
[01:28:58.656]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:58.656]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:58.656]                   3L)]
[01:28:58.656]             }
[01:28:58.656]             function(cond) {
[01:28:58.656]                 is_error <- inherits(cond, "error")
[01:28:58.656]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:58.656]                   NULL)
[01:28:58.656]                 if (is_error) {
[01:28:58.656]                   sessionInformation <- function() {
[01:28:58.656]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:58.656]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:58.656]                       search = base::search(), system = base::Sys.info())
[01:28:58.656]                   }
[01:28:58.656]                   ...future.conditions[[length(...future.conditions) + 
[01:28:58.656]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:58.656]                     cond$call), session = sessionInformation(), 
[01:28:58.656]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:58.656]                   signalCondition(cond)
[01:28:58.656]                 }
[01:28:58.656]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:58.656]                 "immediateCondition"))) {
[01:28:58.656]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:58.656]                   ...future.conditions[[length(...future.conditions) + 
[01:28:58.656]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:58.656]                   if (TRUE && !signal) {
[01:28:58.656]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:58.656]                     {
[01:28:58.656]                       inherits <- base::inherits
[01:28:58.656]                       invokeRestart <- base::invokeRestart
[01:28:58.656]                       is.null <- base::is.null
[01:28:58.656]                       muffled <- FALSE
[01:28:58.656]                       if (inherits(cond, "message")) {
[01:28:58.656]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:58.656]                         if (muffled) 
[01:28:58.656]                           invokeRestart("muffleMessage")
[01:28:58.656]                       }
[01:28:58.656]                       else if (inherits(cond, "warning")) {
[01:28:58.656]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:58.656]                         if (muffled) 
[01:28:58.656]                           invokeRestart("muffleWarning")
[01:28:58.656]                       }
[01:28:58.656]                       else if (inherits(cond, "condition")) {
[01:28:58.656]                         if (!is.null(pattern)) {
[01:28:58.656]                           computeRestarts <- base::computeRestarts
[01:28:58.656]                           grepl <- base::grepl
[01:28:58.656]                           restarts <- computeRestarts(cond)
[01:28:58.656]                           for (restart in restarts) {
[01:28:58.656]                             name <- restart$name
[01:28:58.656]                             if (is.null(name)) 
[01:28:58.656]                               next
[01:28:58.656]                             if (!grepl(pattern, name)) 
[01:28:58.656]                               next
[01:28:58.656]                             invokeRestart(restart)
[01:28:58.656]                             muffled <- TRUE
[01:28:58.656]                             break
[01:28:58.656]                           }
[01:28:58.656]                         }
[01:28:58.656]                       }
[01:28:58.656]                       invisible(muffled)
[01:28:58.656]                     }
[01:28:58.656]                     muffleCondition(cond, pattern = "^muffle")
[01:28:58.656]                   }
[01:28:58.656]                 }
[01:28:58.656]                 else {
[01:28:58.656]                   if (TRUE) {
[01:28:58.656]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:58.656]                     {
[01:28:58.656]                       inherits <- base::inherits
[01:28:58.656]                       invokeRestart <- base::invokeRestart
[01:28:58.656]                       is.null <- base::is.null
[01:28:58.656]                       muffled <- FALSE
[01:28:58.656]                       if (inherits(cond, "message")) {
[01:28:58.656]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:58.656]                         if (muffled) 
[01:28:58.656]                           invokeRestart("muffleMessage")
[01:28:58.656]                       }
[01:28:58.656]                       else if (inherits(cond, "warning")) {
[01:28:58.656]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:58.656]                         if (muffled) 
[01:28:58.656]                           invokeRestart("muffleWarning")
[01:28:58.656]                       }
[01:28:58.656]                       else if (inherits(cond, "condition")) {
[01:28:58.656]                         if (!is.null(pattern)) {
[01:28:58.656]                           computeRestarts <- base::computeRestarts
[01:28:58.656]                           grepl <- base::grepl
[01:28:58.656]                           restarts <- computeRestarts(cond)
[01:28:58.656]                           for (restart in restarts) {
[01:28:58.656]                             name <- restart$name
[01:28:58.656]                             if (is.null(name)) 
[01:28:58.656]                               next
[01:28:58.656]                             if (!grepl(pattern, name)) 
[01:28:58.656]                               next
[01:28:58.656]                             invokeRestart(restart)
[01:28:58.656]                             muffled <- TRUE
[01:28:58.656]                             break
[01:28:58.656]                           }
[01:28:58.656]                         }
[01:28:58.656]                       }
[01:28:58.656]                       invisible(muffled)
[01:28:58.656]                     }
[01:28:58.656]                     muffleCondition(cond, pattern = "^muffle")
[01:28:58.656]                   }
[01:28:58.656]                 }
[01:28:58.656]             }
[01:28:58.656]         }))
[01:28:58.656]     }, error = function(ex) {
[01:28:58.656]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:58.656]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:58.656]                 ...future.rng), started = ...future.startTime, 
[01:28:58.656]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:58.656]             version = "1.8"), class = "FutureResult")
[01:28:58.656]     }, finally = {
[01:28:58.656]         if (!identical(...future.workdir, getwd())) 
[01:28:58.656]             setwd(...future.workdir)
[01:28:58.656]         {
[01:28:58.656]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:58.656]                 ...future.oldOptions$nwarnings <- NULL
[01:28:58.656]             }
[01:28:58.656]             base::options(...future.oldOptions)
[01:28:58.656]             if (.Platform$OS.type == "windows") {
[01:28:58.656]                 old_names <- names(...future.oldEnvVars)
[01:28:58.656]                 envs <- base::Sys.getenv()
[01:28:58.656]                 names <- names(envs)
[01:28:58.656]                 common <- intersect(names, old_names)
[01:28:58.656]                 added <- setdiff(names, old_names)
[01:28:58.656]                 removed <- setdiff(old_names, names)
[01:28:58.656]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:58.656]                   envs[common]]
[01:28:58.656]                 NAMES <- toupper(changed)
[01:28:58.656]                 args <- list()
[01:28:58.656]                 for (kk in seq_along(NAMES)) {
[01:28:58.656]                   name <- changed[[kk]]
[01:28:58.656]                   NAME <- NAMES[[kk]]
[01:28:58.656]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:58.656]                     next
[01:28:58.656]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:58.656]                 }
[01:28:58.656]                 NAMES <- toupper(added)
[01:28:58.656]                 for (kk in seq_along(NAMES)) {
[01:28:58.656]                   name <- added[[kk]]
[01:28:58.656]                   NAME <- NAMES[[kk]]
[01:28:58.656]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:58.656]                     next
[01:28:58.656]                   args[[name]] <- ""
[01:28:58.656]                 }
[01:28:58.656]                 NAMES <- toupper(removed)
[01:28:58.656]                 for (kk in seq_along(NAMES)) {
[01:28:58.656]                   name <- removed[[kk]]
[01:28:58.656]                   NAME <- NAMES[[kk]]
[01:28:58.656]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:58.656]                     next
[01:28:58.656]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:58.656]                 }
[01:28:58.656]                 if (length(args) > 0) 
[01:28:58.656]                   base::do.call(base::Sys.setenv, args = args)
[01:28:58.656]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:58.656]             }
[01:28:58.656]             else {
[01:28:58.656]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:58.656]             }
[01:28:58.656]             {
[01:28:58.656]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:58.656]                   0L) {
[01:28:58.656]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:58.656]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:58.656]                   base::options(opts)
[01:28:58.656]                 }
[01:28:58.656]                 {
[01:28:58.656]                   {
[01:28:58.656]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:58.656]                     NULL
[01:28:58.656]                   }
[01:28:58.656]                   options(future.plan = NULL)
[01:28:58.656]                   if (is.na(NA_character_)) 
[01:28:58.656]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:58.656]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:58.656]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:58.656]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:58.656]                     envir = parent.frame()) 
[01:28:58.656]                   {
[01:28:58.656]                     if (is.function(workers)) 
[01:28:58.656]                       workers <- workers()
[01:28:58.656]                     workers <- structure(as.integer(workers), 
[01:28:58.656]                       class = class(workers))
[01:28:58.656]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:58.656]                       workers >= 1)
[01:28:58.656]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:58.656]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:58.656]                     }
[01:28:58.656]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:58.656]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:58.656]                       envir = envir)
[01:28:58.656]                     if (!future$lazy) 
[01:28:58.656]                       future <- run(future)
[01:28:58.656]                     invisible(future)
[01:28:58.656]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:58.656]                 }
[01:28:58.656]             }
[01:28:58.656]         }
[01:28:58.656]     })
[01:28:58.656]     if (TRUE) {
[01:28:58.656]         base::sink(type = "output", split = FALSE)
[01:28:58.656]         if (TRUE) {
[01:28:58.656]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:58.656]         }
[01:28:58.656]         else {
[01:28:58.656]             ...future.result["stdout"] <- base::list(NULL)
[01:28:58.656]         }
[01:28:58.656]         base::close(...future.stdout)
[01:28:58.656]         ...future.stdout <- NULL
[01:28:58.656]     }
[01:28:58.656]     ...future.result$conditions <- ...future.conditions
[01:28:58.656]     ...future.result$finished <- base::Sys.time()
[01:28:58.656]     ...future.result
[01:28:58.656] }
[01:28:58.734] MultisessionFuture started
[01:28:58.734] - Launch lazy future ... done
[01:28:58.738] run() for 'MultisessionFuture' ... done
[01:28:58.738] getGlobalsAndPackages() ...
[01:28:58.738] Searching for globals...
[01:28:58.739] - globals found: [2] 'list', 'stop'
[01:28:58.740] Searching for globals ... DONE
[01:28:58.740] Resolving globals: FALSE
[01:28:58.740] 
[01:28:58.740] 
[01:28:58.741] getGlobalsAndPackages() ... DONE
- result = FALSE, recursive = -1 ... DONE
- result = FALSE, recursive = 0 ...
[01:28:58.741] getGlobalsAndPackages() ...
[01:28:58.741] Searching for globals...
[01:28:58.743] - globals found: [3] '{', 'Sys.sleep', 'list'
[01:28:58.743] Searching for globals ... DONE
[01:28:58.743] Resolving globals: FALSE
[01:28:58.744] 
[01:28:58.744] 
[01:28:58.744] getGlobalsAndPackages() ... DONE
[01:28:58.744] run() for 'Future' ...
[01:28:58.744] - state: 'created'
[01:28:58.745] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:58.759] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:58.760] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:58.760]   - Field: 'node'
[01:28:58.760]   - Field: 'label'
[01:28:58.760]   - Field: 'local'
[01:28:58.760]   - Field: 'owner'
[01:28:58.761]   - Field: 'envir'
[01:28:58.761]   - Field: 'workers'
[01:28:58.761]   - Field: 'packages'
[01:28:58.761]   - Field: 'gc'
[01:28:58.761]   - Field: 'conditions'
[01:28:58.761]   - Field: 'persistent'
[01:28:58.762]   - Field: 'expr'
[01:28:58.762]   - Field: 'uuid'
[01:28:58.762]   - Field: 'seed'
[01:28:58.762]   - Field: 'version'
[01:28:58.762]   - Field: 'result'
[01:28:58.762]   - Field: 'asynchronous'
[01:28:58.763]   - Field: 'calls'
[01:28:58.763]   - Field: 'globals'
[01:28:58.763]   - Field: 'stdout'
[01:28:58.763]   - Field: 'earlySignal'
[01:28:58.763]   - Field: 'lazy'
[01:28:58.764]   - Field: 'state'
[01:28:58.764] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:58.764] - Launch lazy future ...
[01:28:58.764] Packages needed by the future expression (n = 0): <none>
[01:28:58.765] Packages needed by future strategies (n = 0): <none>
[01:28:58.765] {
[01:28:58.765]     {
[01:28:58.765]         {
[01:28:58.765]             ...future.startTime <- base::Sys.time()
[01:28:58.765]             {
[01:28:58.765]                 {
[01:28:58.765]                   {
[01:28:58.765]                     {
[01:28:58.765]                       base::local({
[01:28:58.765]                         has_future <- base::requireNamespace("future", 
[01:28:58.765]                           quietly = TRUE)
[01:28:58.765]                         if (has_future) {
[01:28:58.765]                           ns <- base::getNamespace("future")
[01:28:58.765]                           version <- ns[[".package"]][["version"]]
[01:28:58.765]                           if (is.null(version)) 
[01:28:58.765]                             version <- utils::packageVersion("future")
[01:28:58.765]                         }
[01:28:58.765]                         else {
[01:28:58.765]                           version <- NULL
[01:28:58.765]                         }
[01:28:58.765]                         if (!has_future || version < "1.8.0") {
[01:28:58.765]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:58.765]                             "", base::R.version$version.string), 
[01:28:58.765]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:58.765]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:58.765]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:58.765]                               "release", "version")], collapse = " "), 
[01:28:58.765]                             hostname = base::Sys.info()[["nodename"]])
[01:28:58.765]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:58.765]                             info)
[01:28:58.765]                           info <- base::paste(info, collapse = "; ")
[01:28:58.765]                           if (!has_future) {
[01:28:58.765]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:58.765]                               info)
[01:28:58.765]                           }
[01:28:58.765]                           else {
[01:28:58.765]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:58.765]                               info, version)
[01:28:58.765]                           }
[01:28:58.765]                           base::stop(msg)
[01:28:58.765]                         }
[01:28:58.765]                       })
[01:28:58.765]                     }
[01:28:58.765]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:58.765]                     base::options(mc.cores = 1L)
[01:28:58.765]                   }
[01:28:58.765]                   options(future.plan = NULL)
[01:28:58.765]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:58.765]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:58.765]                 }
[01:28:58.765]                 ...future.workdir <- getwd()
[01:28:58.765]             }
[01:28:58.765]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:58.765]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:58.765]         }
[01:28:58.765]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:58.765]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:58.765]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:58.765]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:58.765]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:58.765]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:58.765]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:58.765]             base::names(...future.oldOptions))
[01:28:58.765]     }
[01:28:58.765]     if (FALSE) {
[01:28:58.765]     }
[01:28:58.765]     else {
[01:28:58.765]         if (TRUE) {
[01:28:58.765]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:58.765]                 open = "w")
[01:28:58.765]         }
[01:28:58.765]         else {
[01:28:58.765]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:58.765]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:58.765]         }
[01:28:58.765]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:58.765]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:58.765]             base::sink(type = "output", split = FALSE)
[01:28:58.765]             base::close(...future.stdout)
[01:28:58.765]         }, add = TRUE)
[01:28:58.765]     }
[01:28:58.765]     ...future.frame <- base::sys.nframe()
[01:28:58.765]     ...future.conditions <- base::list()
[01:28:58.765]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:58.765]     if (FALSE) {
[01:28:58.765]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:58.765]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:58.765]     }
[01:28:58.765]     ...future.result <- base::tryCatch({
[01:28:58.765]         base::withCallingHandlers({
[01:28:58.765]             ...future.value <- base::withVisible(base::local({
[01:28:58.765]                 ...future.makeSendCondition <- base::local({
[01:28:58.765]                   sendCondition <- NULL
[01:28:58.765]                   function(frame = 1L) {
[01:28:58.765]                     if (is.function(sendCondition)) 
[01:28:58.765]                       return(sendCondition)
[01:28:58.765]                     ns <- getNamespace("parallel")
[01:28:58.765]                     if (exists("sendData", mode = "function", 
[01:28:58.765]                       envir = ns)) {
[01:28:58.765]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:58.765]                         envir = ns)
[01:28:58.765]                       envir <- sys.frame(frame)
[01:28:58.765]                       master <- NULL
[01:28:58.765]                       while (!identical(envir, .GlobalEnv) && 
[01:28:58.765]                         !identical(envir, emptyenv())) {
[01:28:58.765]                         if (exists("master", mode = "list", envir = envir, 
[01:28:58.765]                           inherits = FALSE)) {
[01:28:58.765]                           master <- get("master", mode = "list", 
[01:28:58.765]                             envir = envir, inherits = FALSE)
[01:28:58.765]                           if (inherits(master, c("SOCKnode", 
[01:28:58.765]                             "SOCK0node"))) {
[01:28:58.765]                             sendCondition <<- function(cond) {
[01:28:58.765]                               data <- list(type = "VALUE", value = cond, 
[01:28:58.765]                                 success = TRUE)
[01:28:58.765]                               parallel_sendData(master, data)
[01:28:58.765]                             }
[01:28:58.765]                             return(sendCondition)
[01:28:58.765]                           }
[01:28:58.765]                         }
[01:28:58.765]                         frame <- frame + 1L
[01:28:58.765]                         envir <- sys.frame(frame)
[01:28:58.765]                       }
[01:28:58.765]                     }
[01:28:58.765]                     sendCondition <<- function(cond) NULL
[01:28:58.765]                   }
[01:28:58.765]                 })
[01:28:58.765]                 withCallingHandlers({
[01:28:58.765]                   {
[01:28:58.765]                     Sys.sleep(0.5)
[01:28:58.765]                     list(a = 1, b = 42L)
[01:28:58.765]                   }
[01:28:58.765]                 }, immediateCondition = function(cond) {
[01:28:58.765]                   sendCondition <- ...future.makeSendCondition()
[01:28:58.765]                   sendCondition(cond)
[01:28:58.765]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:58.765]                   {
[01:28:58.765]                     inherits <- base::inherits
[01:28:58.765]                     invokeRestart <- base::invokeRestart
[01:28:58.765]                     is.null <- base::is.null
[01:28:58.765]                     muffled <- FALSE
[01:28:58.765]                     if (inherits(cond, "message")) {
[01:28:58.765]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:58.765]                       if (muffled) 
[01:28:58.765]                         invokeRestart("muffleMessage")
[01:28:58.765]                     }
[01:28:58.765]                     else if (inherits(cond, "warning")) {
[01:28:58.765]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:58.765]                       if (muffled) 
[01:28:58.765]                         invokeRestart("muffleWarning")
[01:28:58.765]                     }
[01:28:58.765]                     else if (inherits(cond, "condition")) {
[01:28:58.765]                       if (!is.null(pattern)) {
[01:28:58.765]                         computeRestarts <- base::computeRestarts
[01:28:58.765]                         grepl <- base::grepl
[01:28:58.765]                         restarts <- computeRestarts(cond)
[01:28:58.765]                         for (restart in restarts) {
[01:28:58.765]                           name <- restart$name
[01:28:58.765]                           if (is.null(name)) 
[01:28:58.765]                             next
[01:28:58.765]                           if (!grepl(pattern, name)) 
[01:28:58.765]                             next
[01:28:58.765]                           invokeRestart(restart)
[01:28:58.765]                           muffled <- TRUE
[01:28:58.765]                           break
[01:28:58.765]                         }
[01:28:58.765]                       }
[01:28:58.765]                     }
[01:28:58.765]                     invisible(muffled)
[01:28:58.765]                   }
[01:28:58.765]                   muffleCondition(cond)
[01:28:58.765]                 })
[01:28:58.765]             }))
[01:28:58.765]             future::FutureResult(value = ...future.value$value, 
[01:28:58.765]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:58.765]                   ...future.rng), globalenv = if (FALSE) 
[01:28:58.765]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:58.765]                     ...future.globalenv.names))
[01:28:58.765]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:58.765]         }, condition = base::local({
[01:28:58.765]             c <- base::c
[01:28:58.765]             inherits <- base::inherits
[01:28:58.765]             invokeRestart <- base::invokeRestart
[01:28:58.765]             length <- base::length
[01:28:58.765]             list <- base::list
[01:28:58.765]             seq.int <- base::seq.int
[01:28:58.765]             signalCondition <- base::signalCondition
[01:28:58.765]             sys.calls <- base::sys.calls
[01:28:58.765]             `[[` <- base::`[[`
[01:28:58.765]             `+` <- base::`+`
[01:28:58.765]             `<<-` <- base::`<<-`
[01:28:58.765]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:58.765]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:58.765]                   3L)]
[01:28:58.765]             }
[01:28:58.765]             function(cond) {
[01:28:58.765]                 is_error <- inherits(cond, "error")
[01:28:58.765]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:58.765]                   NULL)
[01:28:58.765]                 if (is_error) {
[01:28:58.765]                   sessionInformation <- function() {
[01:28:58.765]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:58.765]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:58.765]                       search = base::search(), system = base::Sys.info())
[01:28:58.765]                   }
[01:28:58.765]                   ...future.conditions[[length(...future.conditions) + 
[01:28:58.765]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:58.765]                     cond$call), session = sessionInformation(), 
[01:28:58.765]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:58.765]                   signalCondition(cond)
[01:28:58.765]                 }
[01:28:58.765]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:58.765]                 "immediateCondition"))) {
[01:28:58.765]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:58.765]                   ...future.conditions[[length(...future.conditions) + 
[01:28:58.765]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:58.765]                   if (TRUE && !signal) {
[01:28:58.765]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:58.765]                     {
[01:28:58.765]                       inherits <- base::inherits
[01:28:58.765]                       invokeRestart <- base::invokeRestart
[01:28:58.765]                       is.null <- base::is.null
[01:28:58.765]                       muffled <- FALSE
[01:28:58.765]                       if (inherits(cond, "message")) {
[01:28:58.765]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:58.765]                         if (muffled) 
[01:28:58.765]                           invokeRestart("muffleMessage")
[01:28:58.765]                       }
[01:28:58.765]                       else if (inherits(cond, "warning")) {
[01:28:58.765]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:58.765]                         if (muffled) 
[01:28:58.765]                           invokeRestart("muffleWarning")
[01:28:58.765]                       }
[01:28:58.765]                       else if (inherits(cond, "condition")) {
[01:28:58.765]                         if (!is.null(pattern)) {
[01:28:58.765]                           computeRestarts <- base::computeRestarts
[01:28:58.765]                           grepl <- base::grepl
[01:28:58.765]                           restarts <- computeRestarts(cond)
[01:28:58.765]                           for (restart in restarts) {
[01:28:58.765]                             name <- restart$name
[01:28:58.765]                             if (is.null(name)) 
[01:28:58.765]                               next
[01:28:58.765]                             if (!grepl(pattern, name)) 
[01:28:58.765]                               next
[01:28:58.765]                             invokeRestart(restart)
[01:28:58.765]                             muffled <- TRUE
[01:28:58.765]                             break
[01:28:58.765]                           }
[01:28:58.765]                         }
[01:28:58.765]                       }
[01:28:58.765]                       invisible(muffled)
[01:28:58.765]                     }
[01:28:58.765]                     muffleCondition(cond, pattern = "^muffle")
[01:28:58.765]                   }
[01:28:58.765]                 }
[01:28:58.765]                 else {
[01:28:58.765]                   if (TRUE) {
[01:28:58.765]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:58.765]                     {
[01:28:58.765]                       inherits <- base::inherits
[01:28:58.765]                       invokeRestart <- base::invokeRestart
[01:28:58.765]                       is.null <- base::is.null
[01:28:58.765]                       muffled <- FALSE
[01:28:58.765]                       if (inherits(cond, "message")) {
[01:28:58.765]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:58.765]                         if (muffled) 
[01:28:58.765]                           invokeRestart("muffleMessage")
[01:28:58.765]                       }
[01:28:58.765]                       else if (inherits(cond, "warning")) {
[01:28:58.765]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:58.765]                         if (muffled) 
[01:28:58.765]                           invokeRestart("muffleWarning")
[01:28:58.765]                       }
[01:28:58.765]                       else if (inherits(cond, "condition")) {
[01:28:58.765]                         if (!is.null(pattern)) {
[01:28:58.765]                           computeRestarts <- base::computeRestarts
[01:28:58.765]                           grepl <- base::grepl
[01:28:58.765]                           restarts <- computeRestarts(cond)
[01:28:58.765]                           for (restart in restarts) {
[01:28:58.765]                             name <- restart$name
[01:28:58.765]                             if (is.null(name)) 
[01:28:58.765]                               next
[01:28:58.765]                             if (!grepl(pattern, name)) 
[01:28:58.765]                               next
[01:28:58.765]                             invokeRestart(restart)
[01:28:58.765]                             muffled <- TRUE
[01:28:58.765]                             break
[01:28:58.765]                           }
[01:28:58.765]                         }
[01:28:58.765]                       }
[01:28:58.765]                       invisible(muffled)
[01:28:58.765]                     }
[01:28:58.765]                     muffleCondition(cond, pattern = "^muffle")
[01:28:58.765]                   }
[01:28:58.765]                 }
[01:28:58.765]             }
[01:28:58.765]         }))
[01:28:58.765]     }, error = function(ex) {
[01:28:58.765]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:58.765]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:58.765]                 ...future.rng), started = ...future.startTime, 
[01:28:58.765]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:58.765]             version = "1.8"), class = "FutureResult")
[01:28:58.765]     }, finally = {
[01:28:58.765]         if (!identical(...future.workdir, getwd())) 
[01:28:58.765]             setwd(...future.workdir)
[01:28:58.765]         {
[01:28:58.765]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:58.765]                 ...future.oldOptions$nwarnings <- NULL
[01:28:58.765]             }
[01:28:58.765]             base::options(...future.oldOptions)
[01:28:58.765]             if (.Platform$OS.type == "windows") {
[01:28:58.765]                 old_names <- names(...future.oldEnvVars)
[01:28:58.765]                 envs <- base::Sys.getenv()
[01:28:58.765]                 names <- names(envs)
[01:28:58.765]                 common <- intersect(names, old_names)
[01:28:58.765]                 added <- setdiff(names, old_names)
[01:28:58.765]                 removed <- setdiff(old_names, names)
[01:28:58.765]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:58.765]                   envs[common]]
[01:28:58.765]                 NAMES <- toupper(changed)
[01:28:58.765]                 args <- list()
[01:28:58.765]                 for (kk in seq_along(NAMES)) {
[01:28:58.765]                   name <- changed[[kk]]
[01:28:58.765]                   NAME <- NAMES[[kk]]
[01:28:58.765]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:58.765]                     next
[01:28:58.765]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:58.765]                 }
[01:28:58.765]                 NAMES <- toupper(added)
[01:28:58.765]                 for (kk in seq_along(NAMES)) {
[01:28:58.765]                   name <- added[[kk]]
[01:28:58.765]                   NAME <- NAMES[[kk]]
[01:28:58.765]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:58.765]                     next
[01:28:58.765]                   args[[name]] <- ""
[01:28:58.765]                 }
[01:28:58.765]                 NAMES <- toupper(removed)
[01:28:58.765]                 for (kk in seq_along(NAMES)) {
[01:28:58.765]                   name <- removed[[kk]]
[01:28:58.765]                   NAME <- NAMES[[kk]]
[01:28:58.765]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:58.765]                     next
[01:28:58.765]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:58.765]                 }
[01:28:58.765]                 if (length(args) > 0) 
[01:28:58.765]                   base::do.call(base::Sys.setenv, args = args)
[01:28:58.765]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:58.765]             }
[01:28:58.765]             else {
[01:28:58.765]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:58.765]             }
[01:28:58.765]             {
[01:28:58.765]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:58.765]                   0L) {
[01:28:58.765]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:58.765]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:58.765]                   base::options(opts)
[01:28:58.765]                 }
[01:28:58.765]                 {
[01:28:58.765]                   {
[01:28:58.765]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:58.765]                     NULL
[01:28:58.765]                   }
[01:28:58.765]                   options(future.plan = NULL)
[01:28:58.765]                   if (is.na(NA_character_)) 
[01:28:58.765]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:58.765]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:58.765]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:58.765]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:58.765]                     envir = parent.frame()) 
[01:28:58.765]                   {
[01:28:58.765]                     if (is.function(workers)) 
[01:28:58.765]                       workers <- workers()
[01:28:58.765]                     workers <- structure(as.integer(workers), 
[01:28:58.765]                       class = class(workers))
[01:28:58.765]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:58.765]                       workers >= 1)
[01:28:58.765]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:58.765]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:58.765]                     }
[01:28:58.765]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:58.765]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:58.765]                       envir = envir)
[01:28:58.765]                     if (!future$lazy) 
[01:28:58.765]                       future <- run(future)
[01:28:58.765]                     invisible(future)
[01:28:58.765]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:58.765]                 }
[01:28:58.765]             }
[01:28:58.765]         }
[01:28:58.765]     })
[01:28:58.765]     if (TRUE) {
[01:28:58.765]         base::sink(type = "output", split = FALSE)
[01:28:58.765]         if (TRUE) {
[01:28:58.765]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:58.765]         }
[01:28:58.765]         else {
[01:28:58.765]             ...future.result["stdout"] <- base::list(NULL)
[01:28:58.765]         }
[01:28:58.765]         base::close(...future.stdout)
[01:28:58.765]         ...future.stdout <- NULL
[01:28:58.765]     }
[01:28:58.765]     ...future.result$conditions <- ...future.conditions
[01:28:58.765]     ...future.result$finished <- base::Sys.time()
[01:28:58.765]     ...future.result
[01:28:58.765] }
[01:28:58.771] Poll #1 (0): usedNodes() = 2, workers = 2
[01:28:59.000] receiveMessageFromWorker() for ClusterFuture ...
[01:28:59.001] - Validating connection of MultisessionFuture
[01:28:59.001] - received message: FutureResult
[01:28:59.002] - Received FutureResult
[01:28:59.002] - Erased future from FutureRegistry
[01:28:59.002] result() for ClusterFuture ...
[01:28:59.002] - result already collected: FutureResult
[01:28:59.002] result() for ClusterFuture ... done
[01:28:59.002] signalConditions() ...
[01:28:59.003]  - include = 'immediateCondition'
[01:28:59.003]  - exclude = 
[01:28:59.003]  - resignal = FALSE
[01:28:59.003]  - Number of conditions: 1
[01:28:59.003] signalConditions() ... done
[01:28:59.003] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:59.004] result() for ClusterFuture ...
[01:28:59.004] - result already collected: FutureResult
[01:28:59.004] result() for ClusterFuture ... done
[01:28:59.004] result() for ClusterFuture ...
[01:28:59.004] - result already collected: FutureResult
[01:28:59.004] result() for ClusterFuture ... done
[01:28:59.005] signalConditions() ...
[01:28:59.005]  - include = 'immediateCondition'
[01:28:59.005]  - exclude = 
[01:28:59.005]  - resignal = FALSE
[01:28:59.005]  - Number of conditions: 1
[01:28:59.005] signalConditions() ... done
[01:28:59.007] MultisessionFuture started
[01:28:59.007] - Launch lazy future ... done
[01:28:59.007] run() for 'MultisessionFuture' ... done
[01:28:59.547] receiveMessageFromWorker() for ClusterFuture ...
[01:28:59.548] - Validating connection of MultisessionFuture
[01:28:59.548] - received message: FutureResult
[01:28:59.548] - Received FutureResult
[01:28:59.548] - Erased future from FutureRegistry
[01:28:59.549] result() for ClusterFuture ...
[01:28:59.549] - result already collected: FutureResult
[01:28:59.549] result() for ClusterFuture ... done
[01:28:59.549] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:59.549] A MultisessionFuture was resolved (result was not collected)
[01:28:59.549] getGlobalsAndPackages() ...
[01:28:59.550] Searching for globals...
[01:28:59.551] - globals found: [3] '{', 'Sys.sleep', 'list'
[01:28:59.551] Searching for globals ... DONE
[01:28:59.552] Resolving globals: FALSE
[01:28:59.552] 
[01:28:59.552] 
[01:28:59.552] getGlobalsAndPackages() ... DONE
[01:28:59.553] run() for 'Future' ...
[01:28:59.553] - state: 'created'
[01:28:59.553] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:59.569] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:59.569] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:59.569]   - Field: 'node'
[01:28:59.569]   - Field: 'label'
[01:28:59.569]   - Field: 'local'
[01:28:59.570]   - Field: 'owner'
[01:28:59.570]   - Field: 'envir'
[01:28:59.570]   - Field: 'workers'
[01:28:59.570]   - Field: 'packages'
[01:28:59.570]   - Field: 'gc'
[01:28:59.571]   - Field: 'conditions'
[01:28:59.571]   - Field: 'persistent'
[01:28:59.571]   - Field: 'expr'
[01:28:59.571]   - Field: 'uuid'
[01:28:59.571]   - Field: 'seed'
[01:28:59.571]   - Field: 'version'
[01:28:59.572]   - Field: 'result'
[01:28:59.572]   - Field: 'asynchronous'
[01:28:59.572]   - Field: 'calls'
[01:28:59.572]   - Field: 'globals'
[01:28:59.572]   - Field: 'stdout'
[01:28:59.573]   - Field: 'earlySignal'
[01:28:59.573]   - Field: 'lazy'
[01:28:59.573]   - Field: 'state'
[01:28:59.573] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:59.573] - Launch lazy future ...
[01:28:59.574] Packages needed by the future expression (n = 0): <none>
[01:28:59.574] Packages needed by future strategies (n = 0): <none>
[01:28:59.574] {
[01:28:59.574]     {
[01:28:59.574]         {
[01:28:59.574]             ...future.startTime <- base::Sys.time()
[01:28:59.574]             {
[01:28:59.574]                 {
[01:28:59.574]                   {
[01:28:59.574]                     {
[01:28:59.574]                       base::local({
[01:28:59.574]                         has_future <- base::requireNamespace("future", 
[01:28:59.574]                           quietly = TRUE)
[01:28:59.574]                         if (has_future) {
[01:28:59.574]                           ns <- base::getNamespace("future")
[01:28:59.574]                           version <- ns[[".package"]][["version"]]
[01:28:59.574]                           if (is.null(version)) 
[01:28:59.574]                             version <- utils::packageVersion("future")
[01:28:59.574]                         }
[01:28:59.574]                         else {
[01:28:59.574]                           version <- NULL
[01:28:59.574]                         }
[01:28:59.574]                         if (!has_future || version < "1.8.0") {
[01:28:59.574]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:59.574]                             "", base::R.version$version.string), 
[01:28:59.574]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:59.574]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:59.574]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:59.574]                               "release", "version")], collapse = " "), 
[01:28:59.574]                             hostname = base::Sys.info()[["nodename"]])
[01:28:59.574]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:59.574]                             info)
[01:28:59.574]                           info <- base::paste(info, collapse = "; ")
[01:28:59.574]                           if (!has_future) {
[01:28:59.574]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:59.574]                               info)
[01:28:59.574]                           }
[01:28:59.574]                           else {
[01:28:59.574]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:59.574]                               info, version)
[01:28:59.574]                           }
[01:28:59.574]                           base::stop(msg)
[01:28:59.574]                         }
[01:28:59.574]                       })
[01:28:59.574]                     }
[01:28:59.574]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:59.574]                     base::options(mc.cores = 1L)
[01:28:59.574]                   }
[01:28:59.574]                   options(future.plan = NULL)
[01:28:59.574]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:59.574]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:59.574]                 }
[01:28:59.574]                 ...future.workdir <- getwd()
[01:28:59.574]             }
[01:28:59.574]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:59.574]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:59.574]         }
[01:28:59.574]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:28:59.574]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:59.574]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:28:59.574]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:28:59.574]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:59.574]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:59.574]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:59.574]             base::names(...future.oldOptions))
[01:28:59.574]     }
[01:28:59.574]     if (FALSE) {
[01:28:59.574]     }
[01:28:59.574]     else {
[01:28:59.574]         if (TRUE) {
[01:28:59.574]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:59.574]                 open = "w")
[01:28:59.574]         }
[01:28:59.574]         else {
[01:28:59.574]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:59.574]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:59.574]         }
[01:28:59.574]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:59.574]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:59.574]             base::sink(type = "output", split = FALSE)
[01:28:59.574]             base::close(...future.stdout)
[01:28:59.574]         }, add = TRUE)
[01:28:59.574]     }
[01:28:59.574]     ...future.frame <- base::sys.nframe()
[01:28:59.574]     ...future.conditions <- base::list()
[01:28:59.574]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:59.574]     if (FALSE) {
[01:28:59.574]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:59.574]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:59.574]     }
[01:28:59.574]     ...future.result <- base::tryCatch({
[01:28:59.574]         base::withCallingHandlers({
[01:28:59.574]             ...future.value <- base::withVisible(base::local({
[01:28:59.574]                 ...future.makeSendCondition <- base::local({
[01:28:59.574]                   sendCondition <- NULL
[01:28:59.574]                   function(frame = 1L) {
[01:28:59.574]                     if (is.function(sendCondition)) 
[01:28:59.574]                       return(sendCondition)
[01:28:59.574]                     ns <- getNamespace("parallel")
[01:28:59.574]                     if (exists("sendData", mode = "function", 
[01:28:59.574]                       envir = ns)) {
[01:28:59.574]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:59.574]                         envir = ns)
[01:28:59.574]                       envir <- sys.frame(frame)
[01:28:59.574]                       master <- NULL
[01:28:59.574]                       while (!identical(envir, .GlobalEnv) && 
[01:28:59.574]                         !identical(envir, emptyenv())) {
[01:28:59.574]                         if (exists("master", mode = "list", envir = envir, 
[01:28:59.574]                           inherits = FALSE)) {
[01:28:59.574]                           master <- get("master", mode = "list", 
[01:28:59.574]                             envir = envir, inherits = FALSE)
[01:28:59.574]                           if (inherits(master, c("SOCKnode", 
[01:28:59.574]                             "SOCK0node"))) {
[01:28:59.574]                             sendCondition <<- function(cond) {
[01:28:59.574]                               data <- list(type = "VALUE", value = cond, 
[01:28:59.574]                                 success = TRUE)
[01:28:59.574]                               parallel_sendData(master, data)
[01:28:59.574]                             }
[01:28:59.574]                             return(sendCondition)
[01:28:59.574]                           }
[01:28:59.574]                         }
[01:28:59.574]                         frame <- frame + 1L
[01:28:59.574]                         envir <- sys.frame(frame)
[01:28:59.574]                       }
[01:28:59.574]                     }
[01:28:59.574]                     sendCondition <<- function(cond) NULL
[01:28:59.574]                   }
[01:28:59.574]                 })
[01:28:59.574]                 withCallingHandlers({
[01:28:59.574]                   {
[01:28:59.574]                     Sys.sleep(0.5)
[01:28:59.574]                     list(a = 1, b = 42L)
[01:28:59.574]                   }
[01:28:59.574]                 }, immediateCondition = function(cond) {
[01:28:59.574]                   sendCondition <- ...future.makeSendCondition()
[01:28:59.574]                   sendCondition(cond)
[01:28:59.574]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:59.574]                   {
[01:28:59.574]                     inherits <- base::inherits
[01:28:59.574]                     invokeRestart <- base::invokeRestart
[01:28:59.574]                     is.null <- base::is.null
[01:28:59.574]                     muffled <- FALSE
[01:28:59.574]                     if (inherits(cond, "message")) {
[01:28:59.574]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:59.574]                       if (muffled) 
[01:28:59.574]                         invokeRestart("muffleMessage")
[01:28:59.574]                     }
[01:28:59.574]                     else if (inherits(cond, "warning")) {
[01:28:59.574]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:59.574]                       if (muffled) 
[01:28:59.574]                         invokeRestart("muffleWarning")
[01:28:59.574]                     }
[01:28:59.574]                     else if (inherits(cond, "condition")) {
[01:28:59.574]                       if (!is.null(pattern)) {
[01:28:59.574]                         computeRestarts <- base::computeRestarts
[01:28:59.574]                         grepl <- base::grepl
[01:28:59.574]                         restarts <- computeRestarts(cond)
[01:28:59.574]                         for (restart in restarts) {
[01:28:59.574]                           name <- restart$name
[01:28:59.574]                           if (is.null(name)) 
[01:28:59.574]                             next
[01:28:59.574]                           if (!grepl(pattern, name)) 
[01:28:59.574]                             next
[01:28:59.574]                           invokeRestart(restart)
[01:28:59.574]                           muffled <- TRUE
[01:28:59.574]                           break
[01:28:59.574]                         }
[01:28:59.574]                       }
[01:28:59.574]                     }
[01:28:59.574]                     invisible(muffled)
[01:28:59.574]                   }
[01:28:59.574]                   muffleCondition(cond)
[01:28:59.574]                 })
[01:28:59.574]             }))
[01:28:59.574]             future::FutureResult(value = ...future.value$value, 
[01:28:59.574]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:59.574]                   ...future.rng), globalenv = if (FALSE) 
[01:28:59.574]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:59.574]                     ...future.globalenv.names))
[01:28:59.574]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:59.574]         }, condition = base::local({
[01:28:59.574]             c <- base::c
[01:28:59.574]             inherits <- base::inherits
[01:28:59.574]             invokeRestart <- base::invokeRestart
[01:28:59.574]             length <- base::length
[01:28:59.574]             list <- base::list
[01:28:59.574]             seq.int <- base::seq.int
[01:28:59.574]             signalCondition <- base::signalCondition
[01:28:59.574]             sys.calls <- base::sys.calls
[01:28:59.574]             `[[` <- base::`[[`
[01:28:59.574]             `+` <- base::`+`
[01:28:59.574]             `<<-` <- base::`<<-`
[01:28:59.574]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:59.574]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:59.574]                   3L)]
[01:28:59.574]             }
[01:28:59.574]             function(cond) {
[01:28:59.574]                 is_error <- inherits(cond, "error")
[01:28:59.574]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:59.574]                   NULL)
[01:28:59.574]                 if (is_error) {
[01:28:59.574]                   sessionInformation <- function() {
[01:28:59.574]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:59.574]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:59.574]                       search = base::search(), system = base::Sys.info())
[01:28:59.574]                   }
[01:28:59.574]                   ...future.conditions[[length(...future.conditions) + 
[01:28:59.574]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:59.574]                     cond$call), session = sessionInformation(), 
[01:28:59.574]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:59.574]                   signalCondition(cond)
[01:28:59.574]                 }
[01:28:59.574]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:59.574]                 "immediateCondition"))) {
[01:28:59.574]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:59.574]                   ...future.conditions[[length(...future.conditions) + 
[01:28:59.574]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:59.574]                   if (TRUE && !signal) {
[01:28:59.574]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:59.574]                     {
[01:28:59.574]                       inherits <- base::inherits
[01:28:59.574]                       invokeRestart <- base::invokeRestart
[01:28:59.574]                       is.null <- base::is.null
[01:28:59.574]                       muffled <- FALSE
[01:28:59.574]                       if (inherits(cond, "message")) {
[01:28:59.574]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:59.574]                         if (muffled) 
[01:28:59.574]                           invokeRestart("muffleMessage")
[01:28:59.574]                       }
[01:28:59.574]                       else if (inherits(cond, "warning")) {
[01:28:59.574]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:59.574]                         if (muffled) 
[01:28:59.574]                           invokeRestart("muffleWarning")
[01:28:59.574]                       }
[01:28:59.574]                       else if (inherits(cond, "condition")) {
[01:28:59.574]                         if (!is.null(pattern)) {
[01:28:59.574]                           computeRestarts <- base::computeRestarts
[01:28:59.574]                           grepl <- base::grepl
[01:28:59.574]                           restarts <- computeRestarts(cond)
[01:28:59.574]                           for (restart in restarts) {
[01:28:59.574]                             name <- restart$name
[01:28:59.574]                             if (is.null(name)) 
[01:28:59.574]                               next
[01:28:59.574]                             if (!grepl(pattern, name)) 
[01:28:59.574]                               next
[01:28:59.574]                             invokeRestart(restart)
[01:28:59.574]                             muffled <- TRUE
[01:28:59.574]                             break
[01:28:59.574]                           }
[01:28:59.574]                         }
[01:28:59.574]                       }
[01:28:59.574]                       invisible(muffled)
[01:28:59.574]                     }
[01:28:59.574]                     muffleCondition(cond, pattern = "^muffle")
[01:28:59.574]                   }
[01:28:59.574]                 }
[01:28:59.574]                 else {
[01:28:59.574]                   if (TRUE) {
[01:28:59.574]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:59.574]                     {
[01:28:59.574]                       inherits <- base::inherits
[01:28:59.574]                       invokeRestart <- base::invokeRestart
[01:28:59.574]                       is.null <- base::is.null
[01:28:59.574]                       muffled <- FALSE
[01:28:59.574]                       if (inherits(cond, "message")) {
[01:28:59.574]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:59.574]                         if (muffled) 
[01:28:59.574]                           invokeRestart("muffleMessage")
[01:28:59.574]                       }
[01:28:59.574]                       else if (inherits(cond, "warning")) {
[01:28:59.574]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:59.574]                         if (muffled) 
[01:28:59.574]                           invokeRestart("muffleWarning")
[01:28:59.574]                       }
[01:28:59.574]                       else if (inherits(cond, "condition")) {
[01:28:59.574]                         if (!is.null(pattern)) {
[01:28:59.574]                           computeRestarts <- base::computeRestarts
[01:28:59.574]                           grepl <- base::grepl
[01:28:59.574]                           restarts <- computeRestarts(cond)
[01:28:59.574]                           for (restart in restarts) {
[01:28:59.574]                             name <- restart$name
[01:28:59.574]                             if (is.null(name)) 
[01:28:59.574]                               next
[01:28:59.574]                             if (!grepl(pattern, name)) 
[01:28:59.574]                               next
[01:28:59.574]                             invokeRestart(restart)
[01:28:59.574]                             muffled <- TRUE
[01:28:59.574]                             break
[01:28:59.574]                           }
[01:28:59.574]                         }
[01:28:59.574]                       }
[01:28:59.574]                       invisible(muffled)
[01:28:59.574]                     }
[01:28:59.574]                     muffleCondition(cond, pattern = "^muffle")
[01:28:59.574]                   }
[01:28:59.574]                 }
[01:28:59.574]             }
[01:28:59.574]         }))
[01:28:59.574]     }, error = function(ex) {
[01:28:59.574]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:59.574]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:59.574]                 ...future.rng), started = ...future.startTime, 
[01:28:59.574]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:59.574]             version = "1.8"), class = "FutureResult")
[01:28:59.574]     }, finally = {
[01:28:59.574]         if (!identical(...future.workdir, getwd())) 
[01:28:59.574]             setwd(...future.workdir)
[01:28:59.574]         {
[01:28:59.574]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:59.574]                 ...future.oldOptions$nwarnings <- NULL
[01:28:59.574]             }
[01:28:59.574]             base::options(...future.oldOptions)
[01:28:59.574]             if (.Platform$OS.type == "windows") {
[01:28:59.574]                 old_names <- names(...future.oldEnvVars)
[01:28:59.574]                 envs <- base::Sys.getenv()
[01:28:59.574]                 names <- names(envs)
[01:28:59.574]                 common <- intersect(names, old_names)
[01:28:59.574]                 added <- setdiff(names, old_names)
[01:28:59.574]                 removed <- setdiff(old_names, names)
[01:28:59.574]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:59.574]                   envs[common]]
[01:28:59.574]                 NAMES <- toupper(changed)
[01:28:59.574]                 args <- list()
[01:28:59.574]                 for (kk in seq_along(NAMES)) {
[01:28:59.574]                   name <- changed[[kk]]
[01:28:59.574]                   NAME <- NAMES[[kk]]
[01:28:59.574]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:59.574]                     next
[01:28:59.574]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:59.574]                 }
[01:28:59.574]                 NAMES <- toupper(added)
[01:28:59.574]                 for (kk in seq_along(NAMES)) {
[01:28:59.574]                   name <- added[[kk]]
[01:28:59.574]                   NAME <- NAMES[[kk]]
[01:28:59.574]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:59.574]                     next
[01:28:59.574]                   args[[name]] <- ""
[01:28:59.574]                 }
[01:28:59.574]                 NAMES <- toupper(removed)
[01:28:59.574]                 for (kk in seq_along(NAMES)) {
[01:28:59.574]                   name <- removed[[kk]]
[01:28:59.574]                   NAME <- NAMES[[kk]]
[01:28:59.574]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:59.574]                     next
[01:28:59.574]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:59.574]                 }
[01:28:59.574]                 if (length(args) > 0) 
[01:28:59.574]                   base::do.call(base::Sys.setenv, args = args)
[01:28:59.574]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:59.574]             }
[01:28:59.574]             else {
[01:28:59.574]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:59.574]             }
[01:28:59.574]             {
[01:28:59.574]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:59.574]                   0L) {
[01:28:59.574]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:59.574]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:59.574]                   base::options(opts)
[01:28:59.574]                 }
[01:28:59.574]                 {
[01:28:59.574]                   {
[01:28:59.574]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:59.574]                     NULL
[01:28:59.574]                   }
[01:28:59.574]                   options(future.plan = NULL)
[01:28:59.574]                   if (is.na(NA_character_)) 
[01:28:59.574]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:59.574]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:59.574]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:59.574]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:59.574]                     envir = parent.frame()) 
[01:28:59.574]                   {
[01:28:59.574]                     if (is.function(workers)) 
[01:28:59.574]                       workers <- workers()
[01:28:59.574]                     workers <- structure(as.integer(workers), 
[01:28:59.574]                       class = class(workers))
[01:28:59.574]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:59.574]                       workers >= 1)
[01:28:59.574]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:59.574]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:59.574]                     }
[01:28:59.574]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:59.574]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:59.574]                       envir = envir)
[01:28:59.574]                     if (!future$lazy) 
[01:28:59.574]                       future <- run(future)
[01:28:59.574]                     invisible(future)
[01:28:59.574]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:59.574]                 }
[01:28:59.574]             }
[01:28:59.574]         }
[01:28:59.574]     })
[01:28:59.574]     if (TRUE) {
[01:28:59.574]         base::sink(type = "output", split = FALSE)
[01:28:59.574]         if (TRUE) {
[01:28:59.574]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:59.574]         }
[01:28:59.574]         else {
[01:28:59.574]             ...future.result["stdout"] <- base::list(NULL)
[01:28:59.574]         }
[01:28:59.574]         base::close(...future.stdout)
[01:28:59.574]         ...future.stdout <- NULL
[01:28:59.574]     }
[01:28:59.574]     ...future.result$conditions <- ...future.conditions
[01:28:59.574]     ...future.result$finished <- base::Sys.time()
[01:28:59.574]     ...future.result
[01:28:59.574] }
[01:28:59.580] MultisessionFuture started
[01:28:59.580] - Launch lazy future ... done
[01:28:59.581] run() for 'MultisessionFuture' ... done
[01:29:00.112] receiveMessageFromWorker() for ClusterFuture ...
[01:29:00.112] - Validating connection of MultisessionFuture
[01:29:00.113] - received message: FutureResult
[01:29:00.113] - Received FutureResult
[01:29:00.113] - Erased future from FutureRegistry
[01:29:00.113] result() for ClusterFuture ...
[01:29:00.113] - result already collected: FutureResult
[01:29:00.113] result() for ClusterFuture ... done
[01:29:00.114] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:00.114] A MultisessionFuture was resolved (result was not collected)
- w/ exception ...
[01:29:00.114] getGlobalsAndPackages() ...
[01:29:00.114] Searching for globals...
[01:29:00.115] - globals found: [2] 'list', 'stop'
[01:29:00.115] Searching for globals ... DONE
[01:29:00.116] Resolving globals: FALSE
[01:29:00.116] 
[01:29:00.116] 
[01:29:00.116] getGlobalsAndPackages() ... DONE
[01:29:00.117] run() for 'Future' ...
[01:29:00.117] - state: 'created'
[01:29:00.117] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:00.131] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:00.132] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:00.132]   - Field: 'node'
[01:29:00.132]   - Field: 'label'
[01:29:00.132]   - Field: 'local'
[01:29:00.132]   - Field: 'owner'
[01:29:00.133]   - Field: 'envir'
[01:29:00.133]   - Field: 'workers'
[01:29:00.133]   - Field: 'packages'
[01:29:00.133]   - Field: 'gc'
[01:29:00.133]   - Field: 'conditions'
[01:29:00.133]   - Field: 'persistent'
[01:29:00.134]   - Field: 'expr'
[01:29:00.134]   - Field: 'uuid'
[01:29:00.134]   - Field: 'seed'
[01:29:00.134]   - Field: 'version'
[01:29:00.134]   - Field: 'result'
[01:29:00.135]   - Field: 'asynchronous'
[01:29:00.135]   - Field: 'calls'
[01:29:00.135]   - Field: 'globals'
[01:29:00.135]   - Field: 'stdout'
[01:29:00.135]   - Field: 'earlySignal'
[01:29:00.135]   - Field: 'lazy'
[01:29:00.136]   - Field: 'state'
[01:29:00.136] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:00.136] - Launch lazy future ...
[01:29:00.136] Packages needed by the future expression (n = 0): <none>
[01:29:00.136] Packages needed by future strategies (n = 0): <none>
[01:29:00.137] {
[01:29:00.137]     {
[01:29:00.137]         {
[01:29:00.137]             ...future.startTime <- base::Sys.time()
[01:29:00.137]             {
[01:29:00.137]                 {
[01:29:00.137]                   {
[01:29:00.137]                     {
[01:29:00.137]                       base::local({
[01:29:00.137]                         has_future <- base::requireNamespace("future", 
[01:29:00.137]                           quietly = TRUE)
[01:29:00.137]                         if (has_future) {
[01:29:00.137]                           ns <- base::getNamespace("future")
[01:29:00.137]                           version <- ns[[".package"]][["version"]]
[01:29:00.137]                           if (is.null(version)) 
[01:29:00.137]                             version <- utils::packageVersion("future")
[01:29:00.137]                         }
[01:29:00.137]                         else {
[01:29:00.137]                           version <- NULL
[01:29:00.137]                         }
[01:29:00.137]                         if (!has_future || version < "1.8.0") {
[01:29:00.137]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:00.137]                             "", base::R.version$version.string), 
[01:29:00.137]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:00.137]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:00.137]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:00.137]                               "release", "version")], collapse = " "), 
[01:29:00.137]                             hostname = base::Sys.info()[["nodename"]])
[01:29:00.137]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:00.137]                             info)
[01:29:00.137]                           info <- base::paste(info, collapse = "; ")
[01:29:00.137]                           if (!has_future) {
[01:29:00.137]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:00.137]                               info)
[01:29:00.137]                           }
[01:29:00.137]                           else {
[01:29:00.137]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:00.137]                               info, version)
[01:29:00.137]                           }
[01:29:00.137]                           base::stop(msg)
[01:29:00.137]                         }
[01:29:00.137]                       })
[01:29:00.137]                     }
[01:29:00.137]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:00.137]                     base::options(mc.cores = 1L)
[01:29:00.137]                   }
[01:29:00.137]                   options(future.plan = NULL)
[01:29:00.137]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:00.137]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:00.137]                 }
[01:29:00.137]                 ...future.workdir <- getwd()
[01:29:00.137]             }
[01:29:00.137]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:00.137]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:00.137]         }
[01:29:00.137]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:00.137]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:00.137]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:00.137]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:00.137]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:00.137]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:00.137]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:00.137]             base::names(...future.oldOptions))
[01:29:00.137]     }
[01:29:00.137]     if (FALSE) {
[01:29:00.137]     }
[01:29:00.137]     else {
[01:29:00.137]         if (TRUE) {
[01:29:00.137]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:00.137]                 open = "w")
[01:29:00.137]         }
[01:29:00.137]         else {
[01:29:00.137]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:00.137]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:00.137]         }
[01:29:00.137]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:00.137]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:00.137]             base::sink(type = "output", split = FALSE)
[01:29:00.137]             base::close(...future.stdout)
[01:29:00.137]         }, add = TRUE)
[01:29:00.137]     }
[01:29:00.137]     ...future.frame <- base::sys.nframe()
[01:29:00.137]     ...future.conditions <- base::list()
[01:29:00.137]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:00.137]     if (FALSE) {
[01:29:00.137]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:00.137]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:00.137]     }
[01:29:00.137]     ...future.result <- base::tryCatch({
[01:29:00.137]         base::withCallingHandlers({
[01:29:00.137]             ...future.value <- base::withVisible(base::local({
[01:29:00.137]                 ...future.makeSendCondition <- base::local({
[01:29:00.137]                   sendCondition <- NULL
[01:29:00.137]                   function(frame = 1L) {
[01:29:00.137]                     if (is.function(sendCondition)) 
[01:29:00.137]                       return(sendCondition)
[01:29:00.137]                     ns <- getNamespace("parallel")
[01:29:00.137]                     if (exists("sendData", mode = "function", 
[01:29:00.137]                       envir = ns)) {
[01:29:00.137]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:00.137]                         envir = ns)
[01:29:00.137]                       envir <- sys.frame(frame)
[01:29:00.137]                       master <- NULL
[01:29:00.137]                       while (!identical(envir, .GlobalEnv) && 
[01:29:00.137]                         !identical(envir, emptyenv())) {
[01:29:00.137]                         if (exists("master", mode = "list", envir = envir, 
[01:29:00.137]                           inherits = FALSE)) {
[01:29:00.137]                           master <- get("master", mode = "list", 
[01:29:00.137]                             envir = envir, inherits = FALSE)
[01:29:00.137]                           if (inherits(master, c("SOCKnode", 
[01:29:00.137]                             "SOCK0node"))) {
[01:29:00.137]                             sendCondition <<- function(cond) {
[01:29:00.137]                               data <- list(type = "VALUE", value = cond, 
[01:29:00.137]                                 success = TRUE)
[01:29:00.137]                               parallel_sendData(master, data)
[01:29:00.137]                             }
[01:29:00.137]                             return(sendCondition)
[01:29:00.137]                           }
[01:29:00.137]                         }
[01:29:00.137]                         frame <- frame + 1L
[01:29:00.137]                         envir <- sys.frame(frame)
[01:29:00.137]                       }
[01:29:00.137]                     }
[01:29:00.137]                     sendCondition <<- function(cond) NULL
[01:29:00.137]                   }
[01:29:00.137]                 })
[01:29:00.137]                 withCallingHandlers({
[01:29:00.137]                   list(a = 1, b = 42L, c = stop("Nah!"))
[01:29:00.137]                 }, immediateCondition = function(cond) {
[01:29:00.137]                   sendCondition <- ...future.makeSendCondition()
[01:29:00.137]                   sendCondition(cond)
[01:29:00.137]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:00.137]                   {
[01:29:00.137]                     inherits <- base::inherits
[01:29:00.137]                     invokeRestart <- base::invokeRestart
[01:29:00.137]                     is.null <- base::is.null
[01:29:00.137]                     muffled <- FALSE
[01:29:00.137]                     if (inherits(cond, "message")) {
[01:29:00.137]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:00.137]                       if (muffled) 
[01:29:00.137]                         invokeRestart("muffleMessage")
[01:29:00.137]                     }
[01:29:00.137]                     else if (inherits(cond, "warning")) {
[01:29:00.137]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:00.137]                       if (muffled) 
[01:29:00.137]                         invokeRestart("muffleWarning")
[01:29:00.137]                     }
[01:29:00.137]                     else if (inherits(cond, "condition")) {
[01:29:00.137]                       if (!is.null(pattern)) {
[01:29:00.137]                         computeRestarts <- base::computeRestarts
[01:29:00.137]                         grepl <- base::grepl
[01:29:00.137]                         restarts <- computeRestarts(cond)
[01:29:00.137]                         for (restart in restarts) {
[01:29:00.137]                           name <- restart$name
[01:29:00.137]                           if (is.null(name)) 
[01:29:00.137]                             next
[01:29:00.137]                           if (!grepl(pattern, name)) 
[01:29:00.137]                             next
[01:29:00.137]                           invokeRestart(restart)
[01:29:00.137]                           muffled <- TRUE
[01:29:00.137]                           break
[01:29:00.137]                         }
[01:29:00.137]                       }
[01:29:00.137]                     }
[01:29:00.137]                     invisible(muffled)
[01:29:00.137]                   }
[01:29:00.137]                   muffleCondition(cond)
[01:29:00.137]                 })
[01:29:00.137]             }))
[01:29:00.137]             future::FutureResult(value = ...future.value$value, 
[01:29:00.137]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:00.137]                   ...future.rng), globalenv = if (FALSE) 
[01:29:00.137]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:00.137]                     ...future.globalenv.names))
[01:29:00.137]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:00.137]         }, condition = base::local({
[01:29:00.137]             c <- base::c
[01:29:00.137]             inherits <- base::inherits
[01:29:00.137]             invokeRestart <- base::invokeRestart
[01:29:00.137]             length <- base::length
[01:29:00.137]             list <- base::list
[01:29:00.137]             seq.int <- base::seq.int
[01:29:00.137]             signalCondition <- base::signalCondition
[01:29:00.137]             sys.calls <- base::sys.calls
[01:29:00.137]             `[[` <- base::`[[`
[01:29:00.137]             `+` <- base::`+`
[01:29:00.137]             `<<-` <- base::`<<-`
[01:29:00.137]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:00.137]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:00.137]                   3L)]
[01:29:00.137]             }
[01:29:00.137]             function(cond) {
[01:29:00.137]                 is_error <- inherits(cond, "error")
[01:29:00.137]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:00.137]                   NULL)
[01:29:00.137]                 if (is_error) {
[01:29:00.137]                   sessionInformation <- function() {
[01:29:00.137]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:00.137]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:00.137]                       search = base::search(), system = base::Sys.info())
[01:29:00.137]                   }
[01:29:00.137]                   ...future.conditions[[length(...future.conditions) + 
[01:29:00.137]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:00.137]                     cond$call), session = sessionInformation(), 
[01:29:00.137]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:00.137]                   signalCondition(cond)
[01:29:00.137]                 }
[01:29:00.137]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:00.137]                 "immediateCondition"))) {
[01:29:00.137]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:00.137]                   ...future.conditions[[length(...future.conditions) + 
[01:29:00.137]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:00.137]                   if (TRUE && !signal) {
[01:29:00.137]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:00.137]                     {
[01:29:00.137]                       inherits <- base::inherits
[01:29:00.137]                       invokeRestart <- base::invokeRestart
[01:29:00.137]                       is.null <- base::is.null
[01:29:00.137]                       muffled <- FALSE
[01:29:00.137]                       if (inherits(cond, "message")) {
[01:29:00.137]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:00.137]                         if (muffled) 
[01:29:00.137]                           invokeRestart("muffleMessage")
[01:29:00.137]                       }
[01:29:00.137]                       else if (inherits(cond, "warning")) {
[01:29:00.137]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:00.137]                         if (muffled) 
[01:29:00.137]                           invokeRestart("muffleWarning")
[01:29:00.137]                       }
[01:29:00.137]                       else if (inherits(cond, "condition")) {
[01:29:00.137]                         if (!is.null(pattern)) {
[01:29:00.137]                           computeRestarts <- base::computeRestarts
[01:29:00.137]                           grepl <- base::grepl
[01:29:00.137]                           restarts <- computeRestarts(cond)
[01:29:00.137]                           for (restart in restarts) {
[01:29:00.137]                             name <- restart$name
[01:29:00.137]                             if (is.null(name)) 
[01:29:00.137]                               next
[01:29:00.137]                             if (!grepl(pattern, name)) 
[01:29:00.137]                               next
[01:29:00.137]                             invokeRestart(restart)
[01:29:00.137]                             muffled <- TRUE
[01:29:00.137]                             break
[01:29:00.137]                           }
[01:29:00.137]                         }
[01:29:00.137]                       }
[01:29:00.137]                       invisible(muffled)
[01:29:00.137]                     }
[01:29:00.137]                     muffleCondition(cond, pattern = "^muffle")
[01:29:00.137]                   }
[01:29:00.137]                 }
[01:29:00.137]                 else {
[01:29:00.137]                   if (TRUE) {
[01:29:00.137]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:00.137]                     {
[01:29:00.137]                       inherits <- base::inherits
[01:29:00.137]                       invokeRestart <- base::invokeRestart
[01:29:00.137]                       is.null <- base::is.null
[01:29:00.137]                       muffled <- FALSE
[01:29:00.137]                       if (inherits(cond, "message")) {
[01:29:00.137]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:00.137]                         if (muffled) 
[01:29:00.137]                           invokeRestart("muffleMessage")
[01:29:00.137]                       }
[01:29:00.137]                       else if (inherits(cond, "warning")) {
[01:29:00.137]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:00.137]                         if (muffled) 
[01:29:00.137]                           invokeRestart("muffleWarning")
[01:29:00.137]                       }
[01:29:00.137]                       else if (inherits(cond, "condition")) {
[01:29:00.137]                         if (!is.null(pattern)) {
[01:29:00.137]                           computeRestarts <- base::computeRestarts
[01:29:00.137]                           grepl <- base::grepl
[01:29:00.137]                           restarts <- computeRestarts(cond)
[01:29:00.137]                           for (restart in restarts) {
[01:29:00.137]                             name <- restart$name
[01:29:00.137]                             if (is.null(name)) 
[01:29:00.137]                               next
[01:29:00.137]                             if (!grepl(pattern, name)) 
[01:29:00.137]                               next
[01:29:00.137]                             invokeRestart(restart)
[01:29:00.137]                             muffled <- TRUE
[01:29:00.137]                             break
[01:29:00.137]                           }
[01:29:00.137]                         }
[01:29:00.137]                       }
[01:29:00.137]                       invisible(muffled)
[01:29:00.137]                     }
[01:29:00.137]                     muffleCondition(cond, pattern = "^muffle")
[01:29:00.137]                   }
[01:29:00.137]                 }
[01:29:00.137]             }
[01:29:00.137]         }))
[01:29:00.137]     }, error = function(ex) {
[01:29:00.137]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:00.137]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:00.137]                 ...future.rng), started = ...future.startTime, 
[01:29:00.137]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:00.137]             version = "1.8"), class = "FutureResult")
[01:29:00.137]     }, finally = {
[01:29:00.137]         if (!identical(...future.workdir, getwd())) 
[01:29:00.137]             setwd(...future.workdir)
[01:29:00.137]         {
[01:29:00.137]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:00.137]                 ...future.oldOptions$nwarnings <- NULL
[01:29:00.137]             }
[01:29:00.137]             base::options(...future.oldOptions)
[01:29:00.137]             if (.Platform$OS.type == "windows") {
[01:29:00.137]                 old_names <- names(...future.oldEnvVars)
[01:29:00.137]                 envs <- base::Sys.getenv()
[01:29:00.137]                 names <- names(envs)
[01:29:00.137]                 common <- intersect(names, old_names)
[01:29:00.137]                 added <- setdiff(names, old_names)
[01:29:00.137]                 removed <- setdiff(old_names, names)
[01:29:00.137]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:00.137]                   envs[common]]
[01:29:00.137]                 NAMES <- toupper(changed)
[01:29:00.137]                 args <- list()
[01:29:00.137]                 for (kk in seq_along(NAMES)) {
[01:29:00.137]                   name <- changed[[kk]]
[01:29:00.137]                   NAME <- NAMES[[kk]]
[01:29:00.137]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:00.137]                     next
[01:29:00.137]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:00.137]                 }
[01:29:00.137]                 NAMES <- toupper(added)
[01:29:00.137]                 for (kk in seq_along(NAMES)) {
[01:29:00.137]                   name <- added[[kk]]
[01:29:00.137]                   NAME <- NAMES[[kk]]
[01:29:00.137]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:00.137]                     next
[01:29:00.137]                   args[[name]] <- ""
[01:29:00.137]                 }
[01:29:00.137]                 NAMES <- toupper(removed)
[01:29:00.137]                 for (kk in seq_along(NAMES)) {
[01:29:00.137]                   name <- removed[[kk]]
[01:29:00.137]                   NAME <- NAMES[[kk]]
[01:29:00.137]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:00.137]                     next
[01:29:00.137]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:00.137]                 }
[01:29:00.137]                 if (length(args) > 0) 
[01:29:00.137]                   base::do.call(base::Sys.setenv, args = args)
[01:29:00.137]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:00.137]             }
[01:29:00.137]             else {
[01:29:00.137]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:00.137]             }
[01:29:00.137]             {
[01:29:00.137]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:00.137]                   0L) {
[01:29:00.137]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:00.137]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:00.137]                   base::options(opts)
[01:29:00.137]                 }
[01:29:00.137]                 {
[01:29:00.137]                   {
[01:29:00.137]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:00.137]                     NULL
[01:29:00.137]                   }
[01:29:00.137]                   options(future.plan = NULL)
[01:29:00.137]                   if (is.na(NA_character_)) 
[01:29:00.137]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:00.137]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:00.137]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:00.137]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:00.137]                     envir = parent.frame()) 
[01:29:00.137]                   {
[01:29:00.137]                     if (is.function(workers)) 
[01:29:00.137]                       workers <- workers()
[01:29:00.137]                     workers <- structure(as.integer(workers), 
[01:29:00.137]                       class = class(workers))
[01:29:00.137]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:00.137]                       workers >= 1)
[01:29:00.137]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:00.137]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:00.137]                     }
[01:29:00.137]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:00.137]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:00.137]                       envir = envir)
[01:29:00.137]                     if (!future$lazy) 
[01:29:00.137]                       future <- run(future)
[01:29:00.137]                     invisible(future)
[01:29:00.137]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:00.137]                 }
[01:29:00.137]             }
[01:29:00.137]         }
[01:29:00.137]     })
[01:29:00.137]     if (TRUE) {
[01:29:00.137]         base::sink(type = "output", split = FALSE)
[01:29:00.137]         if (TRUE) {
[01:29:00.137]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:00.137]         }
[01:29:00.137]         else {
[01:29:00.137]             ...future.result["stdout"] <- base::list(NULL)
[01:29:00.137]         }
[01:29:00.137]         base::close(...future.stdout)
[01:29:00.137]         ...future.stdout <- NULL
[01:29:00.137]     }
[01:29:00.137]     ...future.result$conditions <- ...future.conditions
[01:29:00.137]     ...future.result$finished <- base::Sys.time()
[01:29:00.137]     ...future.result
[01:29:00.137] }
[01:29:00.144] MultisessionFuture started
[01:29:00.144] - Launch lazy future ... done
[01:29:00.144] run() for 'MultisessionFuture' ... done
[01:29:00.161] receiveMessageFromWorker() for ClusterFuture ...
[01:29:00.162] - Validating connection of MultisessionFuture
[01:29:00.162] - received message: FutureResult
[01:29:00.163] - Received FutureResult
[01:29:00.163] - Erased future from FutureRegistry
[01:29:00.163] result() for ClusterFuture ...
[01:29:00.163] - result already collected: FutureResult
[01:29:00.163] result() for ClusterFuture ... done
[01:29:00.163] signalConditions() ...
[01:29:00.164]  - include = 'immediateCondition'
[01:29:00.164]  - exclude = 
[01:29:00.164]  - resignal = FALSE
[01:29:00.164]  - Number of conditions: 1
[01:29:00.164] signalConditions() ... done
[01:29:00.164] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:00.165] A MultisessionFuture was resolved (result was not collected)
[01:29:00.165] getGlobalsAndPackages() ...
[01:29:00.165] Searching for globals...
[01:29:00.166] - globals found: [2] 'list', 'stop'
[01:29:00.166] Searching for globals ... DONE
[01:29:00.166] Resolving globals: FALSE
[01:29:00.167] 
[01:29:00.167] 
[01:29:00.167] getGlobalsAndPackages() ... DONE
[01:29:00.167] run() for 'Future' ...
[01:29:00.167] - state: 'created'
[01:29:00.168] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:00.182] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:00.182] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:00.183]   - Field: 'node'
[01:29:00.183]   - Field: 'label'
[01:29:00.183]   - Field: 'local'
[01:29:00.183]   - Field: 'owner'
[01:29:00.183]   - Field: 'envir'
[01:29:00.184]   - Field: 'workers'
[01:29:00.184]   - Field: 'packages'
[01:29:00.184]   - Field: 'gc'
[01:29:00.184]   - Field: 'conditions'
[01:29:00.184]   - Field: 'persistent'
[01:29:00.184]   - Field: 'expr'
[01:29:00.185]   - Field: 'uuid'
[01:29:00.185]   - Field: 'seed'
[01:29:00.185]   - Field: 'version'
[01:29:00.185]   - Field: 'result'
[01:29:00.185]   - Field: 'asynchronous'
[01:29:00.186]   - Field: 'calls'
[01:29:00.186]   - Field: 'globals'
[01:29:00.186]   - Field: 'stdout'
[01:29:00.186]   - Field: 'earlySignal'
[01:29:00.186]   - Field: 'lazy'
[01:29:00.186]   - Field: 'state'
[01:29:00.187] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:00.187] - Launch lazy future ...
[01:29:00.187] Packages needed by the future expression (n = 0): <none>
[01:29:00.187] Packages needed by future strategies (n = 0): <none>
[01:29:00.188] {
[01:29:00.188]     {
[01:29:00.188]         {
[01:29:00.188]             ...future.startTime <- base::Sys.time()
[01:29:00.188]             {
[01:29:00.188]                 {
[01:29:00.188]                   {
[01:29:00.188]                     {
[01:29:00.188]                       base::local({
[01:29:00.188]                         has_future <- base::requireNamespace("future", 
[01:29:00.188]                           quietly = TRUE)
[01:29:00.188]                         if (has_future) {
[01:29:00.188]                           ns <- base::getNamespace("future")
[01:29:00.188]                           version <- ns[[".package"]][["version"]]
[01:29:00.188]                           if (is.null(version)) 
[01:29:00.188]                             version <- utils::packageVersion("future")
[01:29:00.188]                         }
[01:29:00.188]                         else {
[01:29:00.188]                           version <- NULL
[01:29:00.188]                         }
[01:29:00.188]                         if (!has_future || version < "1.8.0") {
[01:29:00.188]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:00.188]                             "", base::R.version$version.string), 
[01:29:00.188]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:00.188]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:00.188]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:00.188]                               "release", "version")], collapse = " "), 
[01:29:00.188]                             hostname = base::Sys.info()[["nodename"]])
[01:29:00.188]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:00.188]                             info)
[01:29:00.188]                           info <- base::paste(info, collapse = "; ")
[01:29:00.188]                           if (!has_future) {
[01:29:00.188]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:00.188]                               info)
[01:29:00.188]                           }
[01:29:00.188]                           else {
[01:29:00.188]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:00.188]                               info, version)
[01:29:00.188]                           }
[01:29:00.188]                           base::stop(msg)
[01:29:00.188]                         }
[01:29:00.188]                       })
[01:29:00.188]                     }
[01:29:00.188]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:00.188]                     base::options(mc.cores = 1L)
[01:29:00.188]                   }
[01:29:00.188]                   options(future.plan = NULL)
[01:29:00.188]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:00.188]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:00.188]                 }
[01:29:00.188]                 ...future.workdir <- getwd()
[01:29:00.188]             }
[01:29:00.188]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:00.188]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:00.188]         }
[01:29:00.188]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:00.188]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:00.188]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:00.188]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:00.188]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:00.188]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:00.188]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:00.188]             base::names(...future.oldOptions))
[01:29:00.188]     }
[01:29:00.188]     if (FALSE) {
[01:29:00.188]     }
[01:29:00.188]     else {
[01:29:00.188]         if (TRUE) {
[01:29:00.188]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:00.188]                 open = "w")
[01:29:00.188]         }
[01:29:00.188]         else {
[01:29:00.188]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:00.188]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:00.188]         }
[01:29:00.188]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:00.188]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:00.188]             base::sink(type = "output", split = FALSE)
[01:29:00.188]             base::close(...future.stdout)
[01:29:00.188]         }, add = TRUE)
[01:29:00.188]     }
[01:29:00.188]     ...future.frame <- base::sys.nframe()
[01:29:00.188]     ...future.conditions <- base::list()
[01:29:00.188]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:00.188]     if (FALSE) {
[01:29:00.188]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:00.188]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:00.188]     }
[01:29:00.188]     ...future.result <- base::tryCatch({
[01:29:00.188]         base::withCallingHandlers({
[01:29:00.188]             ...future.value <- base::withVisible(base::local({
[01:29:00.188]                 ...future.makeSendCondition <- base::local({
[01:29:00.188]                   sendCondition <- NULL
[01:29:00.188]                   function(frame = 1L) {
[01:29:00.188]                     if (is.function(sendCondition)) 
[01:29:00.188]                       return(sendCondition)
[01:29:00.188]                     ns <- getNamespace("parallel")
[01:29:00.188]                     if (exists("sendData", mode = "function", 
[01:29:00.188]                       envir = ns)) {
[01:29:00.188]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:00.188]                         envir = ns)
[01:29:00.188]                       envir <- sys.frame(frame)
[01:29:00.188]                       master <- NULL
[01:29:00.188]                       while (!identical(envir, .GlobalEnv) && 
[01:29:00.188]                         !identical(envir, emptyenv())) {
[01:29:00.188]                         if (exists("master", mode = "list", envir = envir, 
[01:29:00.188]                           inherits = FALSE)) {
[01:29:00.188]                           master <- get("master", mode = "list", 
[01:29:00.188]                             envir = envir, inherits = FALSE)
[01:29:00.188]                           if (inherits(master, c("SOCKnode", 
[01:29:00.188]                             "SOCK0node"))) {
[01:29:00.188]                             sendCondition <<- function(cond) {
[01:29:00.188]                               data <- list(type = "VALUE", value = cond, 
[01:29:00.188]                                 success = TRUE)
[01:29:00.188]                               parallel_sendData(master, data)
[01:29:00.188]                             }
[01:29:00.188]                             return(sendCondition)
[01:29:00.188]                           }
[01:29:00.188]                         }
[01:29:00.188]                         frame <- frame + 1L
[01:29:00.188]                         envir <- sys.frame(frame)
[01:29:00.188]                       }
[01:29:00.188]                     }
[01:29:00.188]                     sendCondition <<- function(cond) NULL
[01:29:00.188]                   }
[01:29:00.188]                 })
[01:29:00.188]                 withCallingHandlers({
[01:29:00.188]                   list(a = 1, b = 42L, c = stop("Nah!"))
[01:29:00.188]                 }, immediateCondition = function(cond) {
[01:29:00.188]                   sendCondition <- ...future.makeSendCondition()
[01:29:00.188]                   sendCondition(cond)
[01:29:00.188]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:00.188]                   {
[01:29:00.188]                     inherits <- base::inherits
[01:29:00.188]                     invokeRestart <- base::invokeRestart
[01:29:00.188]                     is.null <- base::is.null
[01:29:00.188]                     muffled <- FALSE
[01:29:00.188]                     if (inherits(cond, "message")) {
[01:29:00.188]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:00.188]                       if (muffled) 
[01:29:00.188]                         invokeRestart("muffleMessage")
[01:29:00.188]                     }
[01:29:00.188]                     else if (inherits(cond, "warning")) {
[01:29:00.188]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:00.188]                       if (muffled) 
[01:29:00.188]                         invokeRestart("muffleWarning")
[01:29:00.188]                     }
[01:29:00.188]                     else if (inherits(cond, "condition")) {
[01:29:00.188]                       if (!is.null(pattern)) {
[01:29:00.188]                         computeRestarts <- base::computeRestarts
[01:29:00.188]                         grepl <- base::grepl
[01:29:00.188]                         restarts <- computeRestarts(cond)
[01:29:00.188]                         for (restart in restarts) {
[01:29:00.188]                           name <- restart$name
[01:29:00.188]                           if (is.null(name)) 
[01:29:00.188]                             next
[01:29:00.188]                           if (!grepl(pattern, name)) 
[01:29:00.188]                             next
[01:29:00.188]                           invokeRestart(restart)
[01:29:00.188]                           muffled <- TRUE
[01:29:00.188]                           break
[01:29:00.188]                         }
[01:29:00.188]                       }
[01:29:00.188]                     }
[01:29:00.188]                     invisible(muffled)
[01:29:00.188]                   }
[01:29:00.188]                   muffleCondition(cond)
[01:29:00.188]                 })
[01:29:00.188]             }))
[01:29:00.188]             future::FutureResult(value = ...future.value$value, 
[01:29:00.188]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:00.188]                   ...future.rng), globalenv = if (FALSE) 
[01:29:00.188]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:00.188]                     ...future.globalenv.names))
[01:29:00.188]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:00.188]         }, condition = base::local({
[01:29:00.188]             c <- base::c
[01:29:00.188]             inherits <- base::inherits
[01:29:00.188]             invokeRestart <- base::invokeRestart
[01:29:00.188]             length <- base::length
[01:29:00.188]             list <- base::list
[01:29:00.188]             seq.int <- base::seq.int
[01:29:00.188]             signalCondition <- base::signalCondition
[01:29:00.188]             sys.calls <- base::sys.calls
[01:29:00.188]             `[[` <- base::`[[`
[01:29:00.188]             `+` <- base::`+`
[01:29:00.188]             `<<-` <- base::`<<-`
[01:29:00.188]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:00.188]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:00.188]                   3L)]
[01:29:00.188]             }
[01:29:00.188]             function(cond) {
[01:29:00.188]                 is_error <- inherits(cond, "error")
[01:29:00.188]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:00.188]                   NULL)
[01:29:00.188]                 if (is_error) {
[01:29:00.188]                   sessionInformation <- function() {
[01:29:00.188]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:00.188]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:00.188]                       search = base::search(), system = base::Sys.info())
[01:29:00.188]                   }
[01:29:00.188]                   ...future.conditions[[length(...future.conditions) + 
[01:29:00.188]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:00.188]                     cond$call), session = sessionInformation(), 
[01:29:00.188]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:00.188]                   signalCondition(cond)
[01:29:00.188]                 }
[01:29:00.188]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:00.188]                 "immediateCondition"))) {
[01:29:00.188]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:00.188]                   ...future.conditions[[length(...future.conditions) + 
[01:29:00.188]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:00.188]                   if (TRUE && !signal) {
[01:29:00.188]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:00.188]                     {
[01:29:00.188]                       inherits <- base::inherits
[01:29:00.188]                       invokeRestart <- base::invokeRestart
[01:29:00.188]                       is.null <- base::is.null
[01:29:00.188]                       muffled <- FALSE
[01:29:00.188]                       if (inherits(cond, "message")) {
[01:29:00.188]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:00.188]                         if (muffled) 
[01:29:00.188]                           invokeRestart("muffleMessage")
[01:29:00.188]                       }
[01:29:00.188]                       else if (inherits(cond, "warning")) {
[01:29:00.188]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:00.188]                         if (muffled) 
[01:29:00.188]                           invokeRestart("muffleWarning")
[01:29:00.188]                       }
[01:29:00.188]                       else if (inherits(cond, "condition")) {
[01:29:00.188]                         if (!is.null(pattern)) {
[01:29:00.188]                           computeRestarts <- base::computeRestarts
[01:29:00.188]                           grepl <- base::grepl
[01:29:00.188]                           restarts <- computeRestarts(cond)
[01:29:00.188]                           for (restart in restarts) {
[01:29:00.188]                             name <- restart$name
[01:29:00.188]                             if (is.null(name)) 
[01:29:00.188]                               next
[01:29:00.188]                             if (!grepl(pattern, name)) 
[01:29:00.188]                               next
[01:29:00.188]                             invokeRestart(restart)
[01:29:00.188]                             muffled <- TRUE
[01:29:00.188]                             break
[01:29:00.188]                           }
[01:29:00.188]                         }
[01:29:00.188]                       }
[01:29:00.188]                       invisible(muffled)
[01:29:00.188]                     }
[01:29:00.188]                     muffleCondition(cond, pattern = "^muffle")
[01:29:00.188]                   }
[01:29:00.188]                 }
[01:29:00.188]                 else {
[01:29:00.188]                   if (TRUE) {
[01:29:00.188]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:00.188]                     {
[01:29:00.188]                       inherits <- base::inherits
[01:29:00.188]                       invokeRestart <- base::invokeRestart
[01:29:00.188]                       is.null <- base::is.null
[01:29:00.188]                       muffled <- FALSE
[01:29:00.188]                       if (inherits(cond, "message")) {
[01:29:00.188]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:00.188]                         if (muffled) 
[01:29:00.188]                           invokeRestart("muffleMessage")
[01:29:00.188]                       }
[01:29:00.188]                       else if (inherits(cond, "warning")) {
[01:29:00.188]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:00.188]                         if (muffled) 
[01:29:00.188]                           invokeRestart("muffleWarning")
[01:29:00.188]                       }
[01:29:00.188]                       else if (inherits(cond, "condition")) {
[01:29:00.188]                         if (!is.null(pattern)) {
[01:29:00.188]                           computeRestarts <- base::computeRestarts
[01:29:00.188]                           grepl <- base::grepl
[01:29:00.188]                           restarts <- computeRestarts(cond)
[01:29:00.188]                           for (restart in restarts) {
[01:29:00.188]                             name <- restart$name
[01:29:00.188]                             if (is.null(name)) 
[01:29:00.188]                               next
[01:29:00.188]                             if (!grepl(pattern, name)) 
[01:29:00.188]                               next
[01:29:00.188]                             invokeRestart(restart)
[01:29:00.188]                             muffled <- TRUE
[01:29:00.188]                             break
[01:29:00.188]                           }
[01:29:00.188]                         }
[01:29:00.188]                       }
[01:29:00.188]                       invisible(muffled)
[01:29:00.188]                     }
[01:29:00.188]                     muffleCondition(cond, pattern = "^muffle")
[01:29:00.188]                   }
[01:29:00.188]                 }
[01:29:00.188]             }
[01:29:00.188]         }))
[01:29:00.188]     }, error = function(ex) {
[01:29:00.188]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:00.188]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:00.188]                 ...future.rng), started = ...future.startTime, 
[01:29:00.188]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:00.188]             version = "1.8"), class = "FutureResult")
[01:29:00.188]     }, finally = {
[01:29:00.188]         if (!identical(...future.workdir, getwd())) 
[01:29:00.188]             setwd(...future.workdir)
[01:29:00.188]         {
[01:29:00.188]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:00.188]                 ...future.oldOptions$nwarnings <- NULL
[01:29:00.188]             }
[01:29:00.188]             base::options(...future.oldOptions)
[01:29:00.188]             if (.Platform$OS.type == "windows") {
[01:29:00.188]                 old_names <- names(...future.oldEnvVars)
[01:29:00.188]                 envs <- base::Sys.getenv()
[01:29:00.188]                 names <- names(envs)
[01:29:00.188]                 common <- intersect(names, old_names)
[01:29:00.188]                 added <- setdiff(names, old_names)
[01:29:00.188]                 removed <- setdiff(old_names, names)
[01:29:00.188]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:00.188]                   envs[common]]
[01:29:00.188]                 NAMES <- toupper(changed)
[01:29:00.188]                 args <- list()
[01:29:00.188]                 for (kk in seq_along(NAMES)) {
[01:29:00.188]                   name <- changed[[kk]]
[01:29:00.188]                   NAME <- NAMES[[kk]]
[01:29:00.188]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:00.188]                     next
[01:29:00.188]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:00.188]                 }
[01:29:00.188]                 NAMES <- toupper(added)
[01:29:00.188]                 for (kk in seq_along(NAMES)) {
[01:29:00.188]                   name <- added[[kk]]
[01:29:00.188]                   NAME <- NAMES[[kk]]
[01:29:00.188]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:00.188]                     next
[01:29:00.188]                   args[[name]] <- ""
[01:29:00.188]                 }
[01:29:00.188]                 NAMES <- toupper(removed)
[01:29:00.188]                 for (kk in seq_along(NAMES)) {
[01:29:00.188]                   name <- removed[[kk]]
[01:29:00.188]                   NAME <- NAMES[[kk]]
[01:29:00.188]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:00.188]                     next
[01:29:00.188]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:00.188]                 }
[01:29:00.188]                 if (length(args) > 0) 
[01:29:00.188]                   base::do.call(base::Sys.setenv, args = args)
[01:29:00.188]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:00.188]             }
[01:29:00.188]             else {
[01:29:00.188]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:00.188]             }
[01:29:00.188]             {
[01:29:00.188]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:00.188]                   0L) {
[01:29:00.188]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:00.188]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:00.188]                   base::options(opts)
[01:29:00.188]                 }
[01:29:00.188]                 {
[01:29:00.188]                   {
[01:29:00.188]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:00.188]                     NULL
[01:29:00.188]                   }
[01:29:00.188]                   options(future.plan = NULL)
[01:29:00.188]                   if (is.na(NA_character_)) 
[01:29:00.188]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:00.188]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:00.188]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:00.188]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:00.188]                     envir = parent.frame()) 
[01:29:00.188]                   {
[01:29:00.188]                     if (is.function(workers)) 
[01:29:00.188]                       workers <- workers()
[01:29:00.188]                     workers <- structure(as.integer(workers), 
[01:29:00.188]                       class = class(workers))
[01:29:00.188]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:00.188]                       workers >= 1)
[01:29:00.188]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:00.188]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:00.188]                     }
[01:29:00.188]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:00.188]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:00.188]                       envir = envir)
[01:29:00.188]                     if (!future$lazy) 
[01:29:00.188]                       future <- run(future)
[01:29:00.188]                     invisible(future)
[01:29:00.188]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:00.188]                 }
[01:29:00.188]             }
[01:29:00.188]         }
[01:29:00.188]     })
[01:29:00.188]     if (TRUE) {
[01:29:00.188]         base::sink(type = "output", split = FALSE)
[01:29:00.188]         if (TRUE) {
[01:29:00.188]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:00.188]         }
[01:29:00.188]         else {
[01:29:00.188]             ...future.result["stdout"] <- base::list(NULL)
[01:29:00.188]         }
[01:29:00.188]         base::close(...future.stdout)
[01:29:00.188]         ...future.stdout <- NULL
[01:29:00.188]     }
[01:29:00.188]     ...future.result$conditions <- ...future.conditions
[01:29:00.188]     ...future.result$finished <- base::Sys.time()
[01:29:00.188]     ...future.result
[01:29:00.188] }
[01:29:00.194] MultisessionFuture started
[01:29:00.194] - Launch lazy future ... done
[01:29:00.194] run() for 'MultisessionFuture' ... done
[01:29:00.212] receiveMessageFromWorker() for ClusterFuture ...
[01:29:00.212] - Validating connection of MultisessionFuture
[01:29:00.212] - received message: FutureResult
[01:29:00.212] - Received FutureResult
[01:29:00.213] - Erased future from FutureRegistry
[01:29:00.213] result() for ClusterFuture ...
[01:29:00.213] - result already collected: FutureResult
[01:29:00.213] result() for ClusterFuture ... done
[01:29:00.213] signalConditions() ...
[01:29:00.213]  - include = 'immediateCondition'
[01:29:00.214]  - exclude = 
[01:29:00.214]  - resignal = FALSE
[01:29:00.214]  - Number of conditions: 1
[01:29:00.214] signalConditions() ... done
[01:29:00.214] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:00.214] A MultisessionFuture was resolved (result was not collected)
- result = FALSE, recursive = 0 ... DONE
- result = FALSE, recursive = 1 ...
[01:29:00.215] getGlobalsAndPackages() ...
[01:29:00.215] Searching for globals...
[01:29:00.216] - globals found: [3] '{', 'Sys.sleep', 'list'
[01:29:00.217] Searching for globals ... DONE
[01:29:00.217] Resolving globals: FALSE
[01:29:00.217] 
[01:29:00.217] 
[01:29:00.218] getGlobalsAndPackages() ... DONE
[01:29:00.218] run() for 'Future' ...
[01:29:00.218] - state: 'created'
[01:29:00.218] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:00.232] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:00.233] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:00.233]   - Field: 'node'
[01:29:00.233]   - Field: 'label'
[01:29:00.233]   - Field: 'local'
[01:29:00.233]   - Field: 'owner'
[01:29:00.234]   - Field: 'envir'
[01:29:00.234]   - Field: 'workers'
[01:29:00.234]   - Field: 'packages'
[01:29:00.234]   - Field: 'gc'
[01:29:00.234]   - Field: 'conditions'
[01:29:00.234]   - Field: 'persistent'
[01:29:00.235]   - Field: 'expr'
[01:29:00.235]   - Field: 'uuid'
[01:29:00.235]   - Field: 'seed'
[01:29:00.235]   - Field: 'version'
[01:29:00.235]   - Field: 'result'
[01:29:00.236]   - Field: 'asynchronous'
[01:29:00.236]   - Field: 'calls'
[01:29:00.236]   - Field: 'globals'
[01:29:00.236]   - Field: 'stdout'
[01:29:00.236]   - Field: 'earlySignal'
[01:29:00.237]   - Field: 'lazy'
[01:29:00.237]   - Field: 'state'
[01:29:00.237] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:00.237] - Launch lazy future ...
[01:29:00.237] Packages needed by the future expression (n = 0): <none>
[01:29:00.238] Packages needed by future strategies (n = 0): <none>
[01:29:00.238] {
[01:29:00.238]     {
[01:29:00.238]         {
[01:29:00.238]             ...future.startTime <- base::Sys.time()
[01:29:00.238]             {
[01:29:00.238]                 {
[01:29:00.238]                   {
[01:29:00.238]                     {
[01:29:00.238]                       base::local({
[01:29:00.238]                         has_future <- base::requireNamespace("future", 
[01:29:00.238]                           quietly = TRUE)
[01:29:00.238]                         if (has_future) {
[01:29:00.238]                           ns <- base::getNamespace("future")
[01:29:00.238]                           version <- ns[[".package"]][["version"]]
[01:29:00.238]                           if (is.null(version)) 
[01:29:00.238]                             version <- utils::packageVersion("future")
[01:29:00.238]                         }
[01:29:00.238]                         else {
[01:29:00.238]                           version <- NULL
[01:29:00.238]                         }
[01:29:00.238]                         if (!has_future || version < "1.8.0") {
[01:29:00.238]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:00.238]                             "", base::R.version$version.string), 
[01:29:00.238]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:00.238]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:00.238]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:00.238]                               "release", "version")], collapse = " "), 
[01:29:00.238]                             hostname = base::Sys.info()[["nodename"]])
[01:29:00.238]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:00.238]                             info)
[01:29:00.238]                           info <- base::paste(info, collapse = "; ")
[01:29:00.238]                           if (!has_future) {
[01:29:00.238]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:00.238]                               info)
[01:29:00.238]                           }
[01:29:00.238]                           else {
[01:29:00.238]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:00.238]                               info, version)
[01:29:00.238]                           }
[01:29:00.238]                           base::stop(msg)
[01:29:00.238]                         }
[01:29:00.238]                       })
[01:29:00.238]                     }
[01:29:00.238]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:00.238]                     base::options(mc.cores = 1L)
[01:29:00.238]                   }
[01:29:00.238]                   options(future.plan = NULL)
[01:29:00.238]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:00.238]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:00.238]                 }
[01:29:00.238]                 ...future.workdir <- getwd()
[01:29:00.238]             }
[01:29:00.238]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:00.238]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:00.238]         }
[01:29:00.238]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:00.238]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:00.238]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:00.238]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:00.238]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:00.238]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:00.238]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:00.238]             base::names(...future.oldOptions))
[01:29:00.238]     }
[01:29:00.238]     if (FALSE) {
[01:29:00.238]     }
[01:29:00.238]     else {
[01:29:00.238]         if (TRUE) {
[01:29:00.238]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:00.238]                 open = "w")
[01:29:00.238]         }
[01:29:00.238]         else {
[01:29:00.238]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:00.238]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:00.238]         }
[01:29:00.238]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:00.238]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:00.238]             base::sink(type = "output", split = FALSE)
[01:29:00.238]             base::close(...future.stdout)
[01:29:00.238]         }, add = TRUE)
[01:29:00.238]     }
[01:29:00.238]     ...future.frame <- base::sys.nframe()
[01:29:00.238]     ...future.conditions <- base::list()
[01:29:00.238]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:00.238]     if (FALSE) {
[01:29:00.238]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:00.238]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:00.238]     }
[01:29:00.238]     ...future.result <- base::tryCatch({
[01:29:00.238]         base::withCallingHandlers({
[01:29:00.238]             ...future.value <- base::withVisible(base::local({
[01:29:00.238]                 ...future.makeSendCondition <- base::local({
[01:29:00.238]                   sendCondition <- NULL
[01:29:00.238]                   function(frame = 1L) {
[01:29:00.238]                     if (is.function(sendCondition)) 
[01:29:00.238]                       return(sendCondition)
[01:29:00.238]                     ns <- getNamespace("parallel")
[01:29:00.238]                     if (exists("sendData", mode = "function", 
[01:29:00.238]                       envir = ns)) {
[01:29:00.238]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:00.238]                         envir = ns)
[01:29:00.238]                       envir <- sys.frame(frame)
[01:29:00.238]                       master <- NULL
[01:29:00.238]                       while (!identical(envir, .GlobalEnv) && 
[01:29:00.238]                         !identical(envir, emptyenv())) {
[01:29:00.238]                         if (exists("master", mode = "list", envir = envir, 
[01:29:00.238]                           inherits = FALSE)) {
[01:29:00.238]                           master <- get("master", mode = "list", 
[01:29:00.238]                             envir = envir, inherits = FALSE)
[01:29:00.238]                           if (inherits(master, c("SOCKnode", 
[01:29:00.238]                             "SOCK0node"))) {
[01:29:00.238]                             sendCondition <<- function(cond) {
[01:29:00.238]                               data <- list(type = "VALUE", value = cond, 
[01:29:00.238]                                 success = TRUE)
[01:29:00.238]                               parallel_sendData(master, data)
[01:29:00.238]                             }
[01:29:00.238]                             return(sendCondition)
[01:29:00.238]                           }
[01:29:00.238]                         }
[01:29:00.238]                         frame <- frame + 1L
[01:29:00.238]                         envir <- sys.frame(frame)
[01:29:00.238]                       }
[01:29:00.238]                     }
[01:29:00.238]                     sendCondition <<- function(cond) NULL
[01:29:00.238]                   }
[01:29:00.238]                 })
[01:29:00.238]                 withCallingHandlers({
[01:29:00.238]                   {
[01:29:00.238]                     Sys.sleep(0.5)
[01:29:00.238]                     list(a = 1, b = 42L)
[01:29:00.238]                   }
[01:29:00.238]                 }, immediateCondition = function(cond) {
[01:29:00.238]                   sendCondition <- ...future.makeSendCondition()
[01:29:00.238]                   sendCondition(cond)
[01:29:00.238]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:00.238]                   {
[01:29:00.238]                     inherits <- base::inherits
[01:29:00.238]                     invokeRestart <- base::invokeRestart
[01:29:00.238]                     is.null <- base::is.null
[01:29:00.238]                     muffled <- FALSE
[01:29:00.238]                     if (inherits(cond, "message")) {
[01:29:00.238]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:00.238]                       if (muffled) 
[01:29:00.238]                         invokeRestart("muffleMessage")
[01:29:00.238]                     }
[01:29:00.238]                     else if (inherits(cond, "warning")) {
[01:29:00.238]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:00.238]                       if (muffled) 
[01:29:00.238]                         invokeRestart("muffleWarning")
[01:29:00.238]                     }
[01:29:00.238]                     else if (inherits(cond, "condition")) {
[01:29:00.238]                       if (!is.null(pattern)) {
[01:29:00.238]                         computeRestarts <- base::computeRestarts
[01:29:00.238]                         grepl <- base::grepl
[01:29:00.238]                         restarts <- computeRestarts(cond)
[01:29:00.238]                         for (restart in restarts) {
[01:29:00.238]                           name <- restart$name
[01:29:00.238]                           if (is.null(name)) 
[01:29:00.238]                             next
[01:29:00.238]                           if (!grepl(pattern, name)) 
[01:29:00.238]                             next
[01:29:00.238]                           invokeRestart(restart)
[01:29:00.238]                           muffled <- TRUE
[01:29:00.238]                           break
[01:29:00.238]                         }
[01:29:00.238]                       }
[01:29:00.238]                     }
[01:29:00.238]                     invisible(muffled)
[01:29:00.238]                   }
[01:29:00.238]                   muffleCondition(cond)
[01:29:00.238]                 })
[01:29:00.238]             }))
[01:29:00.238]             future::FutureResult(value = ...future.value$value, 
[01:29:00.238]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:00.238]                   ...future.rng), globalenv = if (FALSE) 
[01:29:00.238]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:00.238]                     ...future.globalenv.names))
[01:29:00.238]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:00.238]         }, condition = base::local({
[01:29:00.238]             c <- base::c
[01:29:00.238]             inherits <- base::inherits
[01:29:00.238]             invokeRestart <- base::invokeRestart
[01:29:00.238]             length <- base::length
[01:29:00.238]             list <- base::list
[01:29:00.238]             seq.int <- base::seq.int
[01:29:00.238]             signalCondition <- base::signalCondition
[01:29:00.238]             sys.calls <- base::sys.calls
[01:29:00.238]             `[[` <- base::`[[`
[01:29:00.238]             `+` <- base::`+`
[01:29:00.238]             `<<-` <- base::`<<-`
[01:29:00.238]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:00.238]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:00.238]                   3L)]
[01:29:00.238]             }
[01:29:00.238]             function(cond) {
[01:29:00.238]                 is_error <- inherits(cond, "error")
[01:29:00.238]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:00.238]                   NULL)
[01:29:00.238]                 if (is_error) {
[01:29:00.238]                   sessionInformation <- function() {
[01:29:00.238]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:00.238]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:00.238]                       search = base::search(), system = base::Sys.info())
[01:29:00.238]                   }
[01:29:00.238]                   ...future.conditions[[length(...future.conditions) + 
[01:29:00.238]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:00.238]                     cond$call), session = sessionInformation(), 
[01:29:00.238]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:00.238]                   signalCondition(cond)
[01:29:00.238]                 }
[01:29:00.238]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:00.238]                 "immediateCondition"))) {
[01:29:00.238]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:00.238]                   ...future.conditions[[length(...future.conditions) + 
[01:29:00.238]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:00.238]                   if (TRUE && !signal) {
[01:29:00.238]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:00.238]                     {
[01:29:00.238]                       inherits <- base::inherits
[01:29:00.238]                       invokeRestart <- base::invokeRestart
[01:29:00.238]                       is.null <- base::is.null
[01:29:00.238]                       muffled <- FALSE
[01:29:00.238]                       if (inherits(cond, "message")) {
[01:29:00.238]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:00.238]                         if (muffled) 
[01:29:00.238]                           invokeRestart("muffleMessage")
[01:29:00.238]                       }
[01:29:00.238]                       else if (inherits(cond, "warning")) {
[01:29:00.238]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:00.238]                         if (muffled) 
[01:29:00.238]                           invokeRestart("muffleWarning")
[01:29:00.238]                       }
[01:29:00.238]                       else if (inherits(cond, "condition")) {
[01:29:00.238]                         if (!is.null(pattern)) {
[01:29:00.238]                           computeRestarts <- base::computeRestarts
[01:29:00.238]                           grepl <- base::grepl
[01:29:00.238]                           restarts <- computeRestarts(cond)
[01:29:00.238]                           for (restart in restarts) {
[01:29:00.238]                             name <- restart$name
[01:29:00.238]                             if (is.null(name)) 
[01:29:00.238]                               next
[01:29:00.238]                             if (!grepl(pattern, name)) 
[01:29:00.238]                               next
[01:29:00.238]                             invokeRestart(restart)
[01:29:00.238]                             muffled <- TRUE
[01:29:00.238]                             break
[01:29:00.238]                           }
[01:29:00.238]                         }
[01:29:00.238]                       }
[01:29:00.238]                       invisible(muffled)
[01:29:00.238]                     }
[01:29:00.238]                     muffleCondition(cond, pattern = "^muffle")
[01:29:00.238]                   }
[01:29:00.238]                 }
[01:29:00.238]                 else {
[01:29:00.238]                   if (TRUE) {
[01:29:00.238]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:00.238]                     {
[01:29:00.238]                       inherits <- base::inherits
[01:29:00.238]                       invokeRestart <- base::invokeRestart
[01:29:00.238]                       is.null <- base::is.null
[01:29:00.238]                       muffled <- FALSE
[01:29:00.238]                       if (inherits(cond, "message")) {
[01:29:00.238]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:00.238]                         if (muffled) 
[01:29:00.238]                           invokeRestart("muffleMessage")
[01:29:00.238]                       }
[01:29:00.238]                       else if (inherits(cond, "warning")) {
[01:29:00.238]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:00.238]                         if (muffled) 
[01:29:00.238]                           invokeRestart("muffleWarning")
[01:29:00.238]                       }
[01:29:00.238]                       else if (inherits(cond, "condition")) {
[01:29:00.238]                         if (!is.null(pattern)) {
[01:29:00.238]                           computeRestarts <- base::computeRestarts
[01:29:00.238]                           grepl <- base::grepl
[01:29:00.238]                           restarts <- computeRestarts(cond)
[01:29:00.238]                           for (restart in restarts) {
[01:29:00.238]                             name <- restart$name
[01:29:00.238]                             if (is.null(name)) 
[01:29:00.238]                               next
[01:29:00.238]                             if (!grepl(pattern, name)) 
[01:29:00.238]                               next
[01:29:00.238]                             invokeRestart(restart)
[01:29:00.238]                             muffled <- TRUE
[01:29:00.238]                             break
[01:29:00.238]                           }
[01:29:00.238]                         }
[01:29:00.238]                       }
[01:29:00.238]                       invisible(muffled)
[01:29:00.238]                     }
[01:29:00.238]                     muffleCondition(cond, pattern = "^muffle")
[01:29:00.238]                   }
[01:29:00.238]                 }
[01:29:00.238]             }
[01:29:00.238]         }))
[01:29:00.238]     }, error = function(ex) {
[01:29:00.238]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:00.238]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:00.238]                 ...future.rng), started = ...future.startTime, 
[01:29:00.238]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:00.238]             version = "1.8"), class = "FutureResult")
[01:29:00.238]     }, finally = {
[01:29:00.238]         if (!identical(...future.workdir, getwd())) 
[01:29:00.238]             setwd(...future.workdir)
[01:29:00.238]         {
[01:29:00.238]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:00.238]                 ...future.oldOptions$nwarnings <- NULL
[01:29:00.238]             }
[01:29:00.238]             base::options(...future.oldOptions)
[01:29:00.238]             if (.Platform$OS.type == "windows") {
[01:29:00.238]                 old_names <- names(...future.oldEnvVars)
[01:29:00.238]                 envs <- base::Sys.getenv()
[01:29:00.238]                 names <- names(envs)
[01:29:00.238]                 common <- intersect(names, old_names)
[01:29:00.238]                 added <- setdiff(names, old_names)
[01:29:00.238]                 removed <- setdiff(old_names, names)
[01:29:00.238]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:00.238]                   envs[common]]
[01:29:00.238]                 NAMES <- toupper(changed)
[01:29:00.238]                 args <- list()
[01:29:00.238]                 for (kk in seq_along(NAMES)) {
[01:29:00.238]                   name <- changed[[kk]]
[01:29:00.238]                   NAME <- NAMES[[kk]]
[01:29:00.238]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:00.238]                     next
[01:29:00.238]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:00.238]                 }
[01:29:00.238]                 NAMES <- toupper(added)
[01:29:00.238]                 for (kk in seq_along(NAMES)) {
[01:29:00.238]                   name <- added[[kk]]
[01:29:00.238]                   NAME <- NAMES[[kk]]
[01:29:00.238]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:00.238]                     next
[01:29:00.238]                   args[[name]] <- ""
[01:29:00.238]                 }
[01:29:00.238]                 NAMES <- toupper(removed)
[01:29:00.238]                 for (kk in seq_along(NAMES)) {
[01:29:00.238]                   name <- removed[[kk]]
[01:29:00.238]                   NAME <- NAMES[[kk]]
[01:29:00.238]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:00.238]                     next
[01:29:00.238]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:00.238]                 }
[01:29:00.238]                 if (length(args) > 0) 
[01:29:00.238]                   base::do.call(base::Sys.setenv, args = args)
[01:29:00.238]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:00.238]             }
[01:29:00.238]             else {
[01:29:00.238]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:00.238]             }
[01:29:00.238]             {
[01:29:00.238]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:00.238]                   0L) {
[01:29:00.238]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:00.238]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:00.238]                   base::options(opts)
[01:29:00.238]                 }
[01:29:00.238]                 {
[01:29:00.238]                   {
[01:29:00.238]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:00.238]                     NULL
[01:29:00.238]                   }
[01:29:00.238]                   options(future.plan = NULL)
[01:29:00.238]                   if (is.na(NA_character_)) 
[01:29:00.238]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:00.238]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:00.238]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:00.238]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:00.238]                     envir = parent.frame()) 
[01:29:00.238]                   {
[01:29:00.238]                     if (is.function(workers)) 
[01:29:00.238]                       workers <- workers()
[01:29:00.238]                     workers <- structure(as.integer(workers), 
[01:29:00.238]                       class = class(workers))
[01:29:00.238]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:00.238]                       workers >= 1)
[01:29:00.238]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:00.238]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:00.238]                     }
[01:29:00.238]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:00.238]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:00.238]                       envir = envir)
[01:29:00.238]                     if (!future$lazy) 
[01:29:00.238]                       future <- run(future)
[01:29:00.238]                     invisible(future)
[01:29:00.238]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:00.238]                 }
[01:29:00.238]             }
[01:29:00.238]         }
[01:29:00.238]     })
[01:29:00.238]     if (TRUE) {
[01:29:00.238]         base::sink(type = "output", split = FALSE)
[01:29:00.238]         if (TRUE) {
[01:29:00.238]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:00.238]         }
[01:29:00.238]         else {
[01:29:00.238]             ...future.result["stdout"] <- base::list(NULL)
[01:29:00.238]         }
[01:29:00.238]         base::close(...future.stdout)
[01:29:00.238]         ...future.stdout <- NULL
[01:29:00.238]     }
[01:29:00.238]     ...future.result$conditions <- ...future.conditions
[01:29:00.238]     ...future.result$finished <- base::Sys.time()
[01:29:00.238]     ...future.result
[01:29:00.238] }
[01:29:00.244] MultisessionFuture started
[01:29:00.244] - Launch lazy future ... done
[01:29:00.245] run() for 'MultisessionFuture' ... done
[01:29:00.765] receiveMessageFromWorker() for ClusterFuture ...
[01:29:00.766] - Validating connection of MultisessionFuture
[01:29:00.766] - received message: FutureResult
[01:29:00.766] - Received FutureResult
[01:29:00.766] - Erased future from FutureRegistry
[01:29:00.767] result() for ClusterFuture ...
[01:29:00.767] - result already collected: FutureResult
[01:29:00.767] result() for ClusterFuture ... done
[01:29:00.767] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:00.767] A MultisessionFuture was resolved (result was not collected)
[01:29:00.767] getGlobalsAndPackages() ...
[01:29:00.768] Searching for globals...
[01:29:00.769] - globals found: [3] '{', 'Sys.sleep', 'list'
[01:29:00.769] Searching for globals ... DONE
[01:29:00.770] Resolving globals: FALSE
[01:29:00.770] 
[01:29:00.770] 
[01:29:00.770] getGlobalsAndPackages() ... DONE
[01:29:00.771] run() for 'Future' ...
[01:29:00.771] - state: 'created'
[01:29:00.771] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:00.786] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:00.786] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:00.786]   - Field: 'node'
[01:29:00.786]   - Field: 'label'
[01:29:00.786]   - Field: 'local'
[01:29:00.787]   - Field: 'owner'
[01:29:00.787]   - Field: 'envir'
[01:29:00.787]   - Field: 'workers'
[01:29:00.787]   - Field: 'packages'
[01:29:00.787]   - Field: 'gc'
[01:29:00.788]   - Field: 'conditions'
[01:29:00.788]   - Field: 'persistent'
[01:29:00.788]   - Field: 'expr'
[01:29:00.788]   - Field: 'uuid'
[01:29:00.788]   - Field: 'seed'
[01:29:00.788]   - Field: 'version'
[01:29:00.789]   - Field: 'result'
[01:29:00.789]   - Field: 'asynchronous'
[01:29:00.789]   - Field: 'calls'
[01:29:00.789]   - Field: 'globals'
[01:29:00.789]   - Field: 'stdout'
[01:29:00.790]   - Field: 'earlySignal'
[01:29:00.790]   - Field: 'lazy'
[01:29:00.790]   - Field: 'state'
[01:29:00.790] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:00.790] - Launch lazy future ...
[01:29:00.791] Packages needed by the future expression (n = 0): <none>
[01:29:00.791] Packages needed by future strategies (n = 0): <none>
[01:29:00.791] {
[01:29:00.791]     {
[01:29:00.791]         {
[01:29:00.791]             ...future.startTime <- base::Sys.time()
[01:29:00.791]             {
[01:29:00.791]                 {
[01:29:00.791]                   {
[01:29:00.791]                     {
[01:29:00.791]                       base::local({
[01:29:00.791]                         has_future <- base::requireNamespace("future", 
[01:29:00.791]                           quietly = TRUE)
[01:29:00.791]                         if (has_future) {
[01:29:00.791]                           ns <- base::getNamespace("future")
[01:29:00.791]                           version <- ns[[".package"]][["version"]]
[01:29:00.791]                           if (is.null(version)) 
[01:29:00.791]                             version <- utils::packageVersion("future")
[01:29:00.791]                         }
[01:29:00.791]                         else {
[01:29:00.791]                           version <- NULL
[01:29:00.791]                         }
[01:29:00.791]                         if (!has_future || version < "1.8.0") {
[01:29:00.791]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:00.791]                             "", base::R.version$version.string), 
[01:29:00.791]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:00.791]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:00.791]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:00.791]                               "release", "version")], collapse = " "), 
[01:29:00.791]                             hostname = base::Sys.info()[["nodename"]])
[01:29:00.791]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:00.791]                             info)
[01:29:00.791]                           info <- base::paste(info, collapse = "; ")
[01:29:00.791]                           if (!has_future) {
[01:29:00.791]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:00.791]                               info)
[01:29:00.791]                           }
[01:29:00.791]                           else {
[01:29:00.791]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:00.791]                               info, version)
[01:29:00.791]                           }
[01:29:00.791]                           base::stop(msg)
[01:29:00.791]                         }
[01:29:00.791]                       })
[01:29:00.791]                     }
[01:29:00.791]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:00.791]                     base::options(mc.cores = 1L)
[01:29:00.791]                   }
[01:29:00.791]                   options(future.plan = NULL)
[01:29:00.791]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:00.791]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:00.791]                 }
[01:29:00.791]                 ...future.workdir <- getwd()
[01:29:00.791]             }
[01:29:00.791]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:00.791]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:00.791]         }
[01:29:00.791]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:00.791]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:00.791]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:00.791]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:00.791]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:00.791]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:00.791]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:00.791]             base::names(...future.oldOptions))
[01:29:00.791]     }
[01:29:00.791]     if (FALSE) {
[01:29:00.791]     }
[01:29:00.791]     else {
[01:29:00.791]         if (TRUE) {
[01:29:00.791]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:00.791]                 open = "w")
[01:29:00.791]         }
[01:29:00.791]         else {
[01:29:00.791]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:00.791]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:00.791]         }
[01:29:00.791]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:00.791]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:00.791]             base::sink(type = "output", split = FALSE)
[01:29:00.791]             base::close(...future.stdout)
[01:29:00.791]         }, add = TRUE)
[01:29:00.791]     }
[01:29:00.791]     ...future.frame <- base::sys.nframe()
[01:29:00.791]     ...future.conditions <- base::list()
[01:29:00.791]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:00.791]     if (FALSE) {
[01:29:00.791]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:00.791]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:00.791]     }
[01:29:00.791]     ...future.result <- base::tryCatch({
[01:29:00.791]         base::withCallingHandlers({
[01:29:00.791]             ...future.value <- base::withVisible(base::local({
[01:29:00.791]                 ...future.makeSendCondition <- base::local({
[01:29:00.791]                   sendCondition <- NULL
[01:29:00.791]                   function(frame = 1L) {
[01:29:00.791]                     if (is.function(sendCondition)) 
[01:29:00.791]                       return(sendCondition)
[01:29:00.791]                     ns <- getNamespace("parallel")
[01:29:00.791]                     if (exists("sendData", mode = "function", 
[01:29:00.791]                       envir = ns)) {
[01:29:00.791]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:00.791]                         envir = ns)
[01:29:00.791]                       envir <- sys.frame(frame)
[01:29:00.791]                       master <- NULL
[01:29:00.791]                       while (!identical(envir, .GlobalEnv) && 
[01:29:00.791]                         !identical(envir, emptyenv())) {
[01:29:00.791]                         if (exists("master", mode = "list", envir = envir, 
[01:29:00.791]                           inherits = FALSE)) {
[01:29:00.791]                           master <- get("master", mode = "list", 
[01:29:00.791]                             envir = envir, inherits = FALSE)
[01:29:00.791]                           if (inherits(master, c("SOCKnode", 
[01:29:00.791]                             "SOCK0node"))) {
[01:29:00.791]                             sendCondition <<- function(cond) {
[01:29:00.791]                               data <- list(type = "VALUE", value = cond, 
[01:29:00.791]                                 success = TRUE)
[01:29:00.791]                               parallel_sendData(master, data)
[01:29:00.791]                             }
[01:29:00.791]                             return(sendCondition)
[01:29:00.791]                           }
[01:29:00.791]                         }
[01:29:00.791]                         frame <- frame + 1L
[01:29:00.791]                         envir <- sys.frame(frame)
[01:29:00.791]                       }
[01:29:00.791]                     }
[01:29:00.791]                     sendCondition <<- function(cond) NULL
[01:29:00.791]                   }
[01:29:00.791]                 })
[01:29:00.791]                 withCallingHandlers({
[01:29:00.791]                   {
[01:29:00.791]                     Sys.sleep(0.5)
[01:29:00.791]                     list(a = 1, b = 42L)
[01:29:00.791]                   }
[01:29:00.791]                 }, immediateCondition = function(cond) {
[01:29:00.791]                   sendCondition <- ...future.makeSendCondition()
[01:29:00.791]                   sendCondition(cond)
[01:29:00.791]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:00.791]                   {
[01:29:00.791]                     inherits <- base::inherits
[01:29:00.791]                     invokeRestart <- base::invokeRestart
[01:29:00.791]                     is.null <- base::is.null
[01:29:00.791]                     muffled <- FALSE
[01:29:00.791]                     if (inherits(cond, "message")) {
[01:29:00.791]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:00.791]                       if (muffled) 
[01:29:00.791]                         invokeRestart("muffleMessage")
[01:29:00.791]                     }
[01:29:00.791]                     else if (inherits(cond, "warning")) {
[01:29:00.791]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:00.791]                       if (muffled) 
[01:29:00.791]                         invokeRestart("muffleWarning")
[01:29:00.791]                     }
[01:29:00.791]                     else if (inherits(cond, "condition")) {
[01:29:00.791]                       if (!is.null(pattern)) {
[01:29:00.791]                         computeRestarts <- base::computeRestarts
[01:29:00.791]                         grepl <- base::grepl
[01:29:00.791]                         restarts <- computeRestarts(cond)
[01:29:00.791]                         for (restart in restarts) {
[01:29:00.791]                           name <- restart$name
[01:29:00.791]                           if (is.null(name)) 
[01:29:00.791]                             next
[01:29:00.791]                           if (!grepl(pattern, name)) 
[01:29:00.791]                             next
[01:29:00.791]                           invokeRestart(restart)
[01:29:00.791]                           muffled <- TRUE
[01:29:00.791]                           break
[01:29:00.791]                         }
[01:29:00.791]                       }
[01:29:00.791]                     }
[01:29:00.791]                     invisible(muffled)
[01:29:00.791]                   }
[01:29:00.791]                   muffleCondition(cond)
[01:29:00.791]                 })
[01:29:00.791]             }))
[01:29:00.791]             future::FutureResult(value = ...future.value$value, 
[01:29:00.791]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:00.791]                   ...future.rng), globalenv = if (FALSE) 
[01:29:00.791]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:00.791]                     ...future.globalenv.names))
[01:29:00.791]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:00.791]         }, condition = base::local({
[01:29:00.791]             c <- base::c
[01:29:00.791]             inherits <- base::inherits
[01:29:00.791]             invokeRestart <- base::invokeRestart
[01:29:00.791]             length <- base::length
[01:29:00.791]             list <- base::list
[01:29:00.791]             seq.int <- base::seq.int
[01:29:00.791]             signalCondition <- base::signalCondition
[01:29:00.791]             sys.calls <- base::sys.calls
[01:29:00.791]             `[[` <- base::`[[`
[01:29:00.791]             `+` <- base::`+`
[01:29:00.791]             `<<-` <- base::`<<-`
[01:29:00.791]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:00.791]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:00.791]                   3L)]
[01:29:00.791]             }
[01:29:00.791]             function(cond) {
[01:29:00.791]                 is_error <- inherits(cond, "error")
[01:29:00.791]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:00.791]                   NULL)
[01:29:00.791]                 if (is_error) {
[01:29:00.791]                   sessionInformation <- function() {
[01:29:00.791]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:00.791]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:00.791]                       search = base::search(), system = base::Sys.info())
[01:29:00.791]                   }
[01:29:00.791]                   ...future.conditions[[length(...future.conditions) + 
[01:29:00.791]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:00.791]                     cond$call), session = sessionInformation(), 
[01:29:00.791]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:00.791]                   signalCondition(cond)
[01:29:00.791]                 }
[01:29:00.791]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:00.791]                 "immediateCondition"))) {
[01:29:00.791]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:00.791]                   ...future.conditions[[length(...future.conditions) + 
[01:29:00.791]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:00.791]                   if (TRUE && !signal) {
[01:29:00.791]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:00.791]                     {
[01:29:00.791]                       inherits <- base::inherits
[01:29:00.791]                       invokeRestart <- base::invokeRestart
[01:29:00.791]                       is.null <- base::is.null
[01:29:00.791]                       muffled <- FALSE
[01:29:00.791]                       if (inherits(cond, "message")) {
[01:29:00.791]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:00.791]                         if (muffled) 
[01:29:00.791]                           invokeRestart("muffleMessage")
[01:29:00.791]                       }
[01:29:00.791]                       else if (inherits(cond, "warning")) {
[01:29:00.791]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:00.791]                         if (muffled) 
[01:29:00.791]                           invokeRestart("muffleWarning")
[01:29:00.791]                       }
[01:29:00.791]                       else if (inherits(cond, "condition")) {
[01:29:00.791]                         if (!is.null(pattern)) {
[01:29:00.791]                           computeRestarts <- base::computeRestarts
[01:29:00.791]                           grepl <- base::grepl
[01:29:00.791]                           restarts <- computeRestarts(cond)
[01:29:00.791]                           for (restart in restarts) {
[01:29:00.791]                             name <- restart$name
[01:29:00.791]                             if (is.null(name)) 
[01:29:00.791]                               next
[01:29:00.791]                             if (!grepl(pattern, name)) 
[01:29:00.791]                               next
[01:29:00.791]                             invokeRestart(restart)
[01:29:00.791]                             muffled <- TRUE
[01:29:00.791]                             break
[01:29:00.791]                           }
[01:29:00.791]                         }
[01:29:00.791]                       }
[01:29:00.791]                       invisible(muffled)
[01:29:00.791]                     }
[01:29:00.791]                     muffleCondition(cond, pattern = "^muffle")
[01:29:00.791]                   }
[01:29:00.791]                 }
[01:29:00.791]                 else {
[01:29:00.791]                   if (TRUE) {
[01:29:00.791]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:00.791]                     {
[01:29:00.791]                       inherits <- base::inherits
[01:29:00.791]                       invokeRestart <- base::invokeRestart
[01:29:00.791]                       is.null <- base::is.null
[01:29:00.791]                       muffled <- FALSE
[01:29:00.791]                       if (inherits(cond, "message")) {
[01:29:00.791]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:00.791]                         if (muffled) 
[01:29:00.791]                           invokeRestart("muffleMessage")
[01:29:00.791]                       }
[01:29:00.791]                       else if (inherits(cond, "warning")) {
[01:29:00.791]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:00.791]                         if (muffled) 
[01:29:00.791]                           invokeRestart("muffleWarning")
[01:29:00.791]                       }
[01:29:00.791]                       else if (inherits(cond, "condition")) {
[01:29:00.791]                         if (!is.null(pattern)) {
[01:29:00.791]                           computeRestarts <- base::computeRestarts
[01:29:00.791]                           grepl <- base::grepl
[01:29:00.791]                           restarts <- computeRestarts(cond)
[01:29:00.791]                           for (restart in restarts) {
[01:29:00.791]                             name <- restart$name
[01:29:00.791]                             if (is.null(name)) 
[01:29:00.791]                               next
[01:29:00.791]                             if (!grepl(pattern, name)) 
[01:29:00.791]                               next
[01:29:00.791]                             invokeRestart(restart)
[01:29:00.791]                             muffled <- TRUE
[01:29:00.791]                             break
[01:29:00.791]                           }
[01:29:00.791]                         }
[01:29:00.791]                       }
[01:29:00.791]                       invisible(muffled)
[01:29:00.791]                     }
[01:29:00.791]                     muffleCondition(cond, pattern = "^muffle")
[01:29:00.791]                   }
[01:29:00.791]                 }
[01:29:00.791]             }
[01:29:00.791]         }))
[01:29:00.791]     }, error = function(ex) {
[01:29:00.791]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:00.791]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:00.791]                 ...future.rng), started = ...future.startTime, 
[01:29:00.791]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:00.791]             version = "1.8"), class = "FutureResult")
[01:29:00.791]     }, finally = {
[01:29:00.791]         if (!identical(...future.workdir, getwd())) 
[01:29:00.791]             setwd(...future.workdir)
[01:29:00.791]         {
[01:29:00.791]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:00.791]                 ...future.oldOptions$nwarnings <- NULL
[01:29:00.791]             }
[01:29:00.791]             base::options(...future.oldOptions)
[01:29:00.791]             if (.Platform$OS.type == "windows") {
[01:29:00.791]                 old_names <- names(...future.oldEnvVars)
[01:29:00.791]                 envs <- base::Sys.getenv()
[01:29:00.791]                 names <- names(envs)
[01:29:00.791]                 common <- intersect(names, old_names)
[01:29:00.791]                 added <- setdiff(names, old_names)
[01:29:00.791]                 removed <- setdiff(old_names, names)
[01:29:00.791]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:00.791]                   envs[common]]
[01:29:00.791]                 NAMES <- toupper(changed)
[01:29:00.791]                 args <- list()
[01:29:00.791]                 for (kk in seq_along(NAMES)) {
[01:29:00.791]                   name <- changed[[kk]]
[01:29:00.791]                   NAME <- NAMES[[kk]]
[01:29:00.791]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:00.791]                     next
[01:29:00.791]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:00.791]                 }
[01:29:00.791]                 NAMES <- toupper(added)
[01:29:00.791]                 for (kk in seq_along(NAMES)) {
[01:29:00.791]                   name <- added[[kk]]
[01:29:00.791]                   NAME <- NAMES[[kk]]
[01:29:00.791]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:00.791]                     next
[01:29:00.791]                   args[[name]] <- ""
[01:29:00.791]                 }
[01:29:00.791]                 NAMES <- toupper(removed)
[01:29:00.791]                 for (kk in seq_along(NAMES)) {
[01:29:00.791]                   name <- removed[[kk]]
[01:29:00.791]                   NAME <- NAMES[[kk]]
[01:29:00.791]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:00.791]                     next
[01:29:00.791]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:00.791]                 }
[01:29:00.791]                 if (length(args) > 0) 
[01:29:00.791]                   base::do.call(base::Sys.setenv, args = args)
[01:29:00.791]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:00.791]             }
[01:29:00.791]             else {
[01:29:00.791]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:00.791]             }
[01:29:00.791]             {
[01:29:00.791]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:00.791]                   0L) {
[01:29:00.791]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:00.791]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:00.791]                   base::options(opts)
[01:29:00.791]                 }
[01:29:00.791]                 {
[01:29:00.791]                   {
[01:29:00.791]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:00.791]                     NULL
[01:29:00.791]                   }
[01:29:00.791]                   options(future.plan = NULL)
[01:29:00.791]                   if (is.na(NA_character_)) 
[01:29:00.791]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:00.791]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:00.791]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:00.791]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:00.791]                     envir = parent.frame()) 
[01:29:00.791]                   {
[01:29:00.791]                     if (is.function(workers)) 
[01:29:00.791]                       workers <- workers()
[01:29:00.791]                     workers <- structure(as.integer(workers), 
[01:29:00.791]                       class = class(workers))
[01:29:00.791]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:00.791]                       workers >= 1)
[01:29:00.791]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:00.791]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:00.791]                     }
[01:29:00.791]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:00.791]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:00.791]                       envir = envir)
[01:29:00.791]                     if (!future$lazy) 
[01:29:00.791]                       future <- run(future)
[01:29:00.791]                     invisible(future)
[01:29:00.791]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:00.791]                 }
[01:29:00.791]             }
[01:29:00.791]         }
[01:29:00.791]     })
[01:29:00.791]     if (TRUE) {
[01:29:00.791]         base::sink(type = "output", split = FALSE)
[01:29:00.791]         if (TRUE) {
[01:29:00.791]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:00.791]         }
[01:29:00.791]         else {
[01:29:00.791]             ...future.result["stdout"] <- base::list(NULL)
[01:29:00.791]         }
[01:29:00.791]         base::close(...future.stdout)
[01:29:00.791]         ...future.stdout <- NULL
[01:29:00.791]     }
[01:29:00.791]     ...future.result$conditions <- ...future.conditions
[01:29:00.791]     ...future.result$finished <- base::Sys.time()
[01:29:00.791]     ...future.result
[01:29:00.791] }
[01:29:00.798] MultisessionFuture started
[01:29:00.798] - Launch lazy future ... done
[01:29:00.799] run() for 'MultisessionFuture' ... done
[01:29:01.337] receiveMessageFromWorker() for ClusterFuture ...
[01:29:01.337] - Validating connection of MultisessionFuture
[01:29:01.337] - received message: FutureResult
[01:29:01.337] - Received FutureResult
[01:29:01.338] - Erased future from FutureRegistry
[01:29:01.338] result() for ClusterFuture ...
[01:29:01.338] - result already collected: FutureResult
[01:29:01.340] result() for ClusterFuture ... done
[01:29:01.341] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:01.341] A MultisessionFuture was resolved (result was not collected)
- w/ exception ...
[01:29:01.341] getGlobalsAndPackages() ...
[01:29:01.341] Searching for globals...
[01:29:01.342] - globals found: [2] 'list', 'stop'
[01:29:01.342] Searching for globals ... DONE
[01:29:01.342] Resolving globals: FALSE
[01:29:01.343] 
[01:29:01.343] 
[01:29:01.343] getGlobalsAndPackages() ... DONE
[01:29:01.344] run() for 'Future' ...
[01:29:01.344] - state: 'created'
[01:29:01.344] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:01.358] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:01.358] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:01.359]   - Field: 'node'
[01:29:01.359]   - Field: 'label'
[01:29:01.359]   - Field: 'local'
[01:29:01.359]   - Field: 'owner'
[01:29:01.359]   - Field: 'envir'
[01:29:01.360]   - Field: 'workers'
[01:29:01.360]   - Field: 'packages'
[01:29:01.360]   - Field: 'gc'
[01:29:01.360]   - Field: 'conditions'
[01:29:01.360]   - Field: 'persistent'
[01:29:01.360]   - Field: 'expr'
[01:29:01.361]   - Field: 'uuid'
[01:29:01.361]   - Field: 'seed'
[01:29:01.361]   - Field: 'version'
[01:29:01.361]   - Field: 'result'
[01:29:01.361]   - Field: 'asynchronous'
[01:29:01.361]   - Field: 'calls'
[01:29:01.362]   - Field: 'globals'
[01:29:01.362]   - Field: 'stdout'
[01:29:01.362]   - Field: 'earlySignal'
[01:29:01.362]   - Field: 'lazy'
[01:29:01.362]   - Field: 'state'
[01:29:01.363] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:01.363] - Launch lazy future ...
[01:29:01.363] Packages needed by the future expression (n = 0): <none>
[01:29:01.363] Packages needed by future strategies (n = 0): <none>
[01:29:01.364] {
[01:29:01.364]     {
[01:29:01.364]         {
[01:29:01.364]             ...future.startTime <- base::Sys.time()
[01:29:01.364]             {
[01:29:01.364]                 {
[01:29:01.364]                   {
[01:29:01.364]                     {
[01:29:01.364]                       base::local({
[01:29:01.364]                         has_future <- base::requireNamespace("future", 
[01:29:01.364]                           quietly = TRUE)
[01:29:01.364]                         if (has_future) {
[01:29:01.364]                           ns <- base::getNamespace("future")
[01:29:01.364]                           version <- ns[[".package"]][["version"]]
[01:29:01.364]                           if (is.null(version)) 
[01:29:01.364]                             version <- utils::packageVersion("future")
[01:29:01.364]                         }
[01:29:01.364]                         else {
[01:29:01.364]                           version <- NULL
[01:29:01.364]                         }
[01:29:01.364]                         if (!has_future || version < "1.8.0") {
[01:29:01.364]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:01.364]                             "", base::R.version$version.string), 
[01:29:01.364]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:01.364]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:01.364]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:01.364]                               "release", "version")], collapse = " "), 
[01:29:01.364]                             hostname = base::Sys.info()[["nodename"]])
[01:29:01.364]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:01.364]                             info)
[01:29:01.364]                           info <- base::paste(info, collapse = "; ")
[01:29:01.364]                           if (!has_future) {
[01:29:01.364]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:01.364]                               info)
[01:29:01.364]                           }
[01:29:01.364]                           else {
[01:29:01.364]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:01.364]                               info, version)
[01:29:01.364]                           }
[01:29:01.364]                           base::stop(msg)
[01:29:01.364]                         }
[01:29:01.364]                       })
[01:29:01.364]                     }
[01:29:01.364]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:01.364]                     base::options(mc.cores = 1L)
[01:29:01.364]                   }
[01:29:01.364]                   options(future.plan = NULL)
[01:29:01.364]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:01.364]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:01.364]                 }
[01:29:01.364]                 ...future.workdir <- getwd()
[01:29:01.364]             }
[01:29:01.364]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:01.364]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:01.364]         }
[01:29:01.364]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:01.364]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:01.364]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:01.364]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:01.364]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:01.364]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:01.364]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:01.364]             base::names(...future.oldOptions))
[01:29:01.364]     }
[01:29:01.364]     if (FALSE) {
[01:29:01.364]     }
[01:29:01.364]     else {
[01:29:01.364]         if (TRUE) {
[01:29:01.364]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:01.364]                 open = "w")
[01:29:01.364]         }
[01:29:01.364]         else {
[01:29:01.364]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:01.364]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:01.364]         }
[01:29:01.364]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:01.364]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:01.364]             base::sink(type = "output", split = FALSE)
[01:29:01.364]             base::close(...future.stdout)
[01:29:01.364]         }, add = TRUE)
[01:29:01.364]     }
[01:29:01.364]     ...future.frame <- base::sys.nframe()
[01:29:01.364]     ...future.conditions <- base::list()
[01:29:01.364]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:01.364]     if (FALSE) {
[01:29:01.364]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:01.364]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:01.364]     }
[01:29:01.364]     ...future.result <- base::tryCatch({
[01:29:01.364]         base::withCallingHandlers({
[01:29:01.364]             ...future.value <- base::withVisible(base::local({
[01:29:01.364]                 ...future.makeSendCondition <- base::local({
[01:29:01.364]                   sendCondition <- NULL
[01:29:01.364]                   function(frame = 1L) {
[01:29:01.364]                     if (is.function(sendCondition)) 
[01:29:01.364]                       return(sendCondition)
[01:29:01.364]                     ns <- getNamespace("parallel")
[01:29:01.364]                     if (exists("sendData", mode = "function", 
[01:29:01.364]                       envir = ns)) {
[01:29:01.364]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:01.364]                         envir = ns)
[01:29:01.364]                       envir <- sys.frame(frame)
[01:29:01.364]                       master <- NULL
[01:29:01.364]                       while (!identical(envir, .GlobalEnv) && 
[01:29:01.364]                         !identical(envir, emptyenv())) {
[01:29:01.364]                         if (exists("master", mode = "list", envir = envir, 
[01:29:01.364]                           inherits = FALSE)) {
[01:29:01.364]                           master <- get("master", mode = "list", 
[01:29:01.364]                             envir = envir, inherits = FALSE)
[01:29:01.364]                           if (inherits(master, c("SOCKnode", 
[01:29:01.364]                             "SOCK0node"))) {
[01:29:01.364]                             sendCondition <<- function(cond) {
[01:29:01.364]                               data <- list(type = "VALUE", value = cond, 
[01:29:01.364]                                 success = TRUE)
[01:29:01.364]                               parallel_sendData(master, data)
[01:29:01.364]                             }
[01:29:01.364]                             return(sendCondition)
[01:29:01.364]                           }
[01:29:01.364]                         }
[01:29:01.364]                         frame <- frame + 1L
[01:29:01.364]                         envir <- sys.frame(frame)
[01:29:01.364]                       }
[01:29:01.364]                     }
[01:29:01.364]                     sendCondition <<- function(cond) NULL
[01:29:01.364]                   }
[01:29:01.364]                 })
[01:29:01.364]                 withCallingHandlers({
[01:29:01.364]                   list(a = 1, b = 42L, c = stop("Nah!"))
[01:29:01.364]                 }, immediateCondition = function(cond) {
[01:29:01.364]                   sendCondition <- ...future.makeSendCondition()
[01:29:01.364]                   sendCondition(cond)
[01:29:01.364]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:01.364]                   {
[01:29:01.364]                     inherits <- base::inherits
[01:29:01.364]                     invokeRestart <- base::invokeRestart
[01:29:01.364]                     is.null <- base::is.null
[01:29:01.364]                     muffled <- FALSE
[01:29:01.364]                     if (inherits(cond, "message")) {
[01:29:01.364]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:01.364]                       if (muffled) 
[01:29:01.364]                         invokeRestart("muffleMessage")
[01:29:01.364]                     }
[01:29:01.364]                     else if (inherits(cond, "warning")) {
[01:29:01.364]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:01.364]                       if (muffled) 
[01:29:01.364]                         invokeRestart("muffleWarning")
[01:29:01.364]                     }
[01:29:01.364]                     else if (inherits(cond, "condition")) {
[01:29:01.364]                       if (!is.null(pattern)) {
[01:29:01.364]                         computeRestarts <- base::computeRestarts
[01:29:01.364]                         grepl <- base::grepl
[01:29:01.364]                         restarts <- computeRestarts(cond)
[01:29:01.364]                         for (restart in restarts) {
[01:29:01.364]                           name <- restart$name
[01:29:01.364]                           if (is.null(name)) 
[01:29:01.364]                             next
[01:29:01.364]                           if (!grepl(pattern, name)) 
[01:29:01.364]                             next
[01:29:01.364]                           invokeRestart(restart)
[01:29:01.364]                           muffled <- TRUE
[01:29:01.364]                           break
[01:29:01.364]                         }
[01:29:01.364]                       }
[01:29:01.364]                     }
[01:29:01.364]                     invisible(muffled)
[01:29:01.364]                   }
[01:29:01.364]                   muffleCondition(cond)
[01:29:01.364]                 })
[01:29:01.364]             }))
[01:29:01.364]             future::FutureResult(value = ...future.value$value, 
[01:29:01.364]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:01.364]                   ...future.rng), globalenv = if (FALSE) 
[01:29:01.364]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:01.364]                     ...future.globalenv.names))
[01:29:01.364]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:01.364]         }, condition = base::local({
[01:29:01.364]             c <- base::c
[01:29:01.364]             inherits <- base::inherits
[01:29:01.364]             invokeRestart <- base::invokeRestart
[01:29:01.364]             length <- base::length
[01:29:01.364]             list <- base::list
[01:29:01.364]             seq.int <- base::seq.int
[01:29:01.364]             signalCondition <- base::signalCondition
[01:29:01.364]             sys.calls <- base::sys.calls
[01:29:01.364]             `[[` <- base::`[[`
[01:29:01.364]             `+` <- base::`+`
[01:29:01.364]             `<<-` <- base::`<<-`
[01:29:01.364]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:01.364]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:01.364]                   3L)]
[01:29:01.364]             }
[01:29:01.364]             function(cond) {
[01:29:01.364]                 is_error <- inherits(cond, "error")
[01:29:01.364]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:01.364]                   NULL)
[01:29:01.364]                 if (is_error) {
[01:29:01.364]                   sessionInformation <- function() {
[01:29:01.364]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:01.364]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:01.364]                       search = base::search(), system = base::Sys.info())
[01:29:01.364]                   }
[01:29:01.364]                   ...future.conditions[[length(...future.conditions) + 
[01:29:01.364]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:01.364]                     cond$call), session = sessionInformation(), 
[01:29:01.364]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:01.364]                   signalCondition(cond)
[01:29:01.364]                 }
[01:29:01.364]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:01.364]                 "immediateCondition"))) {
[01:29:01.364]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:01.364]                   ...future.conditions[[length(...future.conditions) + 
[01:29:01.364]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:01.364]                   if (TRUE && !signal) {
[01:29:01.364]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:01.364]                     {
[01:29:01.364]                       inherits <- base::inherits
[01:29:01.364]                       invokeRestart <- base::invokeRestart
[01:29:01.364]                       is.null <- base::is.null
[01:29:01.364]                       muffled <- FALSE
[01:29:01.364]                       if (inherits(cond, "message")) {
[01:29:01.364]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:01.364]                         if (muffled) 
[01:29:01.364]                           invokeRestart("muffleMessage")
[01:29:01.364]                       }
[01:29:01.364]                       else if (inherits(cond, "warning")) {
[01:29:01.364]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:01.364]                         if (muffled) 
[01:29:01.364]                           invokeRestart("muffleWarning")
[01:29:01.364]                       }
[01:29:01.364]                       else if (inherits(cond, "condition")) {
[01:29:01.364]                         if (!is.null(pattern)) {
[01:29:01.364]                           computeRestarts <- base::computeRestarts
[01:29:01.364]                           grepl <- base::grepl
[01:29:01.364]                           restarts <- computeRestarts(cond)
[01:29:01.364]                           for (restart in restarts) {
[01:29:01.364]                             name <- restart$name
[01:29:01.364]                             if (is.null(name)) 
[01:29:01.364]                               next
[01:29:01.364]                             if (!grepl(pattern, name)) 
[01:29:01.364]                               next
[01:29:01.364]                             invokeRestart(restart)
[01:29:01.364]                             muffled <- TRUE
[01:29:01.364]                             break
[01:29:01.364]                           }
[01:29:01.364]                         }
[01:29:01.364]                       }
[01:29:01.364]                       invisible(muffled)
[01:29:01.364]                     }
[01:29:01.364]                     muffleCondition(cond, pattern = "^muffle")
[01:29:01.364]                   }
[01:29:01.364]                 }
[01:29:01.364]                 else {
[01:29:01.364]                   if (TRUE) {
[01:29:01.364]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:01.364]                     {
[01:29:01.364]                       inherits <- base::inherits
[01:29:01.364]                       invokeRestart <- base::invokeRestart
[01:29:01.364]                       is.null <- base::is.null
[01:29:01.364]                       muffled <- FALSE
[01:29:01.364]                       if (inherits(cond, "message")) {
[01:29:01.364]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:01.364]                         if (muffled) 
[01:29:01.364]                           invokeRestart("muffleMessage")
[01:29:01.364]                       }
[01:29:01.364]                       else if (inherits(cond, "warning")) {
[01:29:01.364]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:01.364]                         if (muffled) 
[01:29:01.364]                           invokeRestart("muffleWarning")
[01:29:01.364]                       }
[01:29:01.364]                       else if (inherits(cond, "condition")) {
[01:29:01.364]                         if (!is.null(pattern)) {
[01:29:01.364]                           computeRestarts <- base::computeRestarts
[01:29:01.364]                           grepl <- base::grepl
[01:29:01.364]                           restarts <- computeRestarts(cond)
[01:29:01.364]                           for (restart in restarts) {
[01:29:01.364]                             name <- restart$name
[01:29:01.364]                             if (is.null(name)) 
[01:29:01.364]                               next
[01:29:01.364]                             if (!grepl(pattern, name)) 
[01:29:01.364]                               next
[01:29:01.364]                             invokeRestart(restart)
[01:29:01.364]                             muffled <- TRUE
[01:29:01.364]                             break
[01:29:01.364]                           }
[01:29:01.364]                         }
[01:29:01.364]                       }
[01:29:01.364]                       invisible(muffled)
[01:29:01.364]                     }
[01:29:01.364]                     muffleCondition(cond, pattern = "^muffle")
[01:29:01.364]                   }
[01:29:01.364]                 }
[01:29:01.364]             }
[01:29:01.364]         }))
[01:29:01.364]     }, error = function(ex) {
[01:29:01.364]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:01.364]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:01.364]                 ...future.rng), started = ...future.startTime, 
[01:29:01.364]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:01.364]             version = "1.8"), class = "FutureResult")
[01:29:01.364]     }, finally = {
[01:29:01.364]         if (!identical(...future.workdir, getwd())) 
[01:29:01.364]             setwd(...future.workdir)
[01:29:01.364]         {
[01:29:01.364]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:01.364]                 ...future.oldOptions$nwarnings <- NULL
[01:29:01.364]             }
[01:29:01.364]             base::options(...future.oldOptions)
[01:29:01.364]             if (.Platform$OS.type == "windows") {
[01:29:01.364]                 old_names <- names(...future.oldEnvVars)
[01:29:01.364]                 envs <- base::Sys.getenv()
[01:29:01.364]                 names <- names(envs)
[01:29:01.364]                 common <- intersect(names, old_names)
[01:29:01.364]                 added <- setdiff(names, old_names)
[01:29:01.364]                 removed <- setdiff(old_names, names)
[01:29:01.364]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:01.364]                   envs[common]]
[01:29:01.364]                 NAMES <- toupper(changed)
[01:29:01.364]                 args <- list()
[01:29:01.364]                 for (kk in seq_along(NAMES)) {
[01:29:01.364]                   name <- changed[[kk]]
[01:29:01.364]                   NAME <- NAMES[[kk]]
[01:29:01.364]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:01.364]                     next
[01:29:01.364]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:01.364]                 }
[01:29:01.364]                 NAMES <- toupper(added)
[01:29:01.364]                 for (kk in seq_along(NAMES)) {
[01:29:01.364]                   name <- added[[kk]]
[01:29:01.364]                   NAME <- NAMES[[kk]]
[01:29:01.364]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:01.364]                     next
[01:29:01.364]                   args[[name]] <- ""
[01:29:01.364]                 }
[01:29:01.364]                 NAMES <- toupper(removed)
[01:29:01.364]                 for (kk in seq_along(NAMES)) {
[01:29:01.364]                   name <- removed[[kk]]
[01:29:01.364]                   NAME <- NAMES[[kk]]
[01:29:01.364]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:01.364]                     next
[01:29:01.364]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:01.364]                 }
[01:29:01.364]                 if (length(args) > 0) 
[01:29:01.364]                   base::do.call(base::Sys.setenv, args = args)
[01:29:01.364]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:01.364]             }
[01:29:01.364]             else {
[01:29:01.364]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:01.364]             }
[01:29:01.364]             {
[01:29:01.364]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:01.364]                   0L) {
[01:29:01.364]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:01.364]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:01.364]                   base::options(opts)
[01:29:01.364]                 }
[01:29:01.364]                 {
[01:29:01.364]                   {
[01:29:01.364]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:01.364]                     NULL
[01:29:01.364]                   }
[01:29:01.364]                   options(future.plan = NULL)
[01:29:01.364]                   if (is.na(NA_character_)) 
[01:29:01.364]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:01.364]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:01.364]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:01.364]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:01.364]                     envir = parent.frame()) 
[01:29:01.364]                   {
[01:29:01.364]                     if (is.function(workers)) 
[01:29:01.364]                       workers <- workers()
[01:29:01.364]                     workers <- structure(as.integer(workers), 
[01:29:01.364]                       class = class(workers))
[01:29:01.364]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:01.364]                       workers >= 1)
[01:29:01.364]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:01.364]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:01.364]                     }
[01:29:01.364]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:01.364]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:01.364]                       envir = envir)
[01:29:01.364]                     if (!future$lazy) 
[01:29:01.364]                       future <- run(future)
[01:29:01.364]                     invisible(future)
[01:29:01.364]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:01.364]                 }
[01:29:01.364]             }
[01:29:01.364]         }
[01:29:01.364]     })
[01:29:01.364]     if (TRUE) {
[01:29:01.364]         base::sink(type = "output", split = FALSE)
[01:29:01.364]         if (TRUE) {
[01:29:01.364]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:01.364]         }
[01:29:01.364]         else {
[01:29:01.364]             ...future.result["stdout"] <- base::list(NULL)
[01:29:01.364]         }
[01:29:01.364]         base::close(...future.stdout)
[01:29:01.364]         ...future.stdout <- NULL
[01:29:01.364]     }
[01:29:01.364]     ...future.result$conditions <- ...future.conditions
[01:29:01.364]     ...future.result$finished <- base::Sys.time()
[01:29:01.364]     ...future.result
[01:29:01.364] }
[01:29:01.370] MultisessionFuture started
[01:29:01.370] - Launch lazy future ... done
[01:29:01.370] run() for 'MultisessionFuture' ... done
[01:29:01.394] receiveMessageFromWorker() for ClusterFuture ...
[01:29:01.395] - Validating connection of MultisessionFuture
[01:29:01.395] - received message: FutureResult
[01:29:01.395] - Received FutureResult
[01:29:01.395] - Erased future from FutureRegistry
[01:29:01.396] result() for ClusterFuture ...
[01:29:01.396] - result already collected: FutureResult
[01:29:01.396] result() for ClusterFuture ... done
[01:29:01.396] signalConditions() ...
[01:29:01.396]  - include = 'immediateCondition'
[01:29:01.397]  - exclude = 
[01:29:01.397]  - resignal = FALSE
[01:29:01.397]  - Number of conditions: 1
[01:29:01.397] signalConditions() ... done
[01:29:01.397] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:01.397] A MultisessionFuture was resolved (result was not collected)
[01:29:01.398] getGlobalsAndPackages() ...
[01:29:01.398] Searching for globals...
[01:29:01.399] - globals found: [2] 'list', 'stop'
[01:29:01.399] Searching for globals ... DONE
[01:29:01.399] Resolving globals: FALSE
[01:29:01.399] 
[01:29:01.399] 
[01:29:01.400] getGlobalsAndPackages() ... DONE
[01:29:01.400] run() for 'Future' ...
[01:29:01.400] - state: 'created'
[01:29:01.400] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:01.415] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:01.415] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:01.415]   - Field: 'node'
[01:29:01.415]   - Field: 'label'
[01:29:01.416]   - Field: 'local'
[01:29:01.416]   - Field: 'owner'
[01:29:01.416]   - Field: 'envir'
[01:29:01.416]   - Field: 'workers'
[01:29:01.416]   - Field: 'packages'
[01:29:01.416]   - Field: 'gc'
[01:29:01.417]   - Field: 'conditions'
[01:29:01.417]   - Field: 'persistent'
[01:29:01.417]   - Field: 'expr'
[01:29:01.417]   - Field: 'uuid'
[01:29:01.417]   - Field: 'seed'
[01:29:01.418]   - Field: 'version'
[01:29:01.418]   - Field: 'result'
[01:29:01.418]   - Field: 'asynchronous'
[01:29:01.418]   - Field: 'calls'
[01:29:01.418]   - Field: 'globals'
[01:29:01.418]   - Field: 'stdout'
[01:29:01.419]   - Field: 'earlySignal'
[01:29:01.419]   - Field: 'lazy'
[01:29:01.419]   - Field: 'state'
[01:29:01.419] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:01.419] - Launch lazy future ...
[01:29:01.420] Packages needed by the future expression (n = 0): <none>
[01:29:01.420] Packages needed by future strategies (n = 0): <none>
[01:29:01.420] {
[01:29:01.420]     {
[01:29:01.420]         {
[01:29:01.420]             ...future.startTime <- base::Sys.time()
[01:29:01.420]             {
[01:29:01.420]                 {
[01:29:01.420]                   {
[01:29:01.420]                     {
[01:29:01.420]                       base::local({
[01:29:01.420]                         has_future <- base::requireNamespace("future", 
[01:29:01.420]                           quietly = TRUE)
[01:29:01.420]                         if (has_future) {
[01:29:01.420]                           ns <- base::getNamespace("future")
[01:29:01.420]                           version <- ns[[".package"]][["version"]]
[01:29:01.420]                           if (is.null(version)) 
[01:29:01.420]                             version <- utils::packageVersion("future")
[01:29:01.420]                         }
[01:29:01.420]                         else {
[01:29:01.420]                           version <- NULL
[01:29:01.420]                         }
[01:29:01.420]                         if (!has_future || version < "1.8.0") {
[01:29:01.420]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:01.420]                             "", base::R.version$version.string), 
[01:29:01.420]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:01.420]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:01.420]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:01.420]                               "release", "version")], collapse = " "), 
[01:29:01.420]                             hostname = base::Sys.info()[["nodename"]])
[01:29:01.420]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:01.420]                             info)
[01:29:01.420]                           info <- base::paste(info, collapse = "; ")
[01:29:01.420]                           if (!has_future) {
[01:29:01.420]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:01.420]                               info)
[01:29:01.420]                           }
[01:29:01.420]                           else {
[01:29:01.420]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:01.420]                               info, version)
[01:29:01.420]                           }
[01:29:01.420]                           base::stop(msg)
[01:29:01.420]                         }
[01:29:01.420]                       })
[01:29:01.420]                     }
[01:29:01.420]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:01.420]                     base::options(mc.cores = 1L)
[01:29:01.420]                   }
[01:29:01.420]                   options(future.plan = NULL)
[01:29:01.420]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:01.420]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:01.420]                 }
[01:29:01.420]                 ...future.workdir <- getwd()
[01:29:01.420]             }
[01:29:01.420]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:01.420]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:01.420]         }
[01:29:01.420]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:01.420]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:01.420]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:01.420]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:01.420]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:01.420]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:01.420]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:01.420]             base::names(...future.oldOptions))
[01:29:01.420]     }
[01:29:01.420]     if (FALSE) {
[01:29:01.420]     }
[01:29:01.420]     else {
[01:29:01.420]         if (TRUE) {
[01:29:01.420]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:01.420]                 open = "w")
[01:29:01.420]         }
[01:29:01.420]         else {
[01:29:01.420]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:01.420]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:01.420]         }
[01:29:01.420]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:01.420]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:01.420]             base::sink(type = "output", split = FALSE)
[01:29:01.420]             base::close(...future.stdout)
[01:29:01.420]         }, add = TRUE)
[01:29:01.420]     }
[01:29:01.420]     ...future.frame <- base::sys.nframe()
[01:29:01.420]     ...future.conditions <- base::list()
[01:29:01.420]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:01.420]     if (FALSE) {
[01:29:01.420]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:01.420]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:01.420]     }
[01:29:01.420]     ...future.result <- base::tryCatch({
[01:29:01.420]         base::withCallingHandlers({
[01:29:01.420]             ...future.value <- base::withVisible(base::local({
[01:29:01.420]                 ...future.makeSendCondition <- base::local({
[01:29:01.420]                   sendCondition <- NULL
[01:29:01.420]                   function(frame = 1L) {
[01:29:01.420]                     if (is.function(sendCondition)) 
[01:29:01.420]                       return(sendCondition)
[01:29:01.420]                     ns <- getNamespace("parallel")
[01:29:01.420]                     if (exists("sendData", mode = "function", 
[01:29:01.420]                       envir = ns)) {
[01:29:01.420]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:01.420]                         envir = ns)
[01:29:01.420]                       envir <- sys.frame(frame)
[01:29:01.420]                       master <- NULL
[01:29:01.420]                       while (!identical(envir, .GlobalEnv) && 
[01:29:01.420]                         !identical(envir, emptyenv())) {
[01:29:01.420]                         if (exists("master", mode = "list", envir = envir, 
[01:29:01.420]                           inherits = FALSE)) {
[01:29:01.420]                           master <- get("master", mode = "list", 
[01:29:01.420]                             envir = envir, inherits = FALSE)
[01:29:01.420]                           if (inherits(master, c("SOCKnode", 
[01:29:01.420]                             "SOCK0node"))) {
[01:29:01.420]                             sendCondition <<- function(cond) {
[01:29:01.420]                               data <- list(type = "VALUE", value = cond, 
[01:29:01.420]                                 success = TRUE)
[01:29:01.420]                               parallel_sendData(master, data)
[01:29:01.420]                             }
[01:29:01.420]                             return(sendCondition)
[01:29:01.420]                           }
[01:29:01.420]                         }
[01:29:01.420]                         frame <- frame + 1L
[01:29:01.420]                         envir <- sys.frame(frame)
[01:29:01.420]                       }
[01:29:01.420]                     }
[01:29:01.420]                     sendCondition <<- function(cond) NULL
[01:29:01.420]                   }
[01:29:01.420]                 })
[01:29:01.420]                 withCallingHandlers({
[01:29:01.420]                   list(a = 1, b = 42L, c = stop("Nah!"))
[01:29:01.420]                 }, immediateCondition = function(cond) {
[01:29:01.420]                   sendCondition <- ...future.makeSendCondition()
[01:29:01.420]                   sendCondition(cond)
[01:29:01.420]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:01.420]                   {
[01:29:01.420]                     inherits <- base::inherits
[01:29:01.420]                     invokeRestart <- base::invokeRestart
[01:29:01.420]                     is.null <- base::is.null
[01:29:01.420]                     muffled <- FALSE
[01:29:01.420]                     if (inherits(cond, "message")) {
[01:29:01.420]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:01.420]                       if (muffled) 
[01:29:01.420]                         invokeRestart("muffleMessage")
[01:29:01.420]                     }
[01:29:01.420]                     else if (inherits(cond, "warning")) {
[01:29:01.420]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:01.420]                       if (muffled) 
[01:29:01.420]                         invokeRestart("muffleWarning")
[01:29:01.420]                     }
[01:29:01.420]                     else if (inherits(cond, "condition")) {
[01:29:01.420]                       if (!is.null(pattern)) {
[01:29:01.420]                         computeRestarts <- base::computeRestarts
[01:29:01.420]                         grepl <- base::grepl
[01:29:01.420]                         restarts <- computeRestarts(cond)
[01:29:01.420]                         for (restart in restarts) {
[01:29:01.420]                           name <- restart$name
[01:29:01.420]                           if (is.null(name)) 
[01:29:01.420]                             next
[01:29:01.420]                           if (!grepl(pattern, name)) 
[01:29:01.420]                             next
[01:29:01.420]                           invokeRestart(restart)
[01:29:01.420]                           muffled <- TRUE
[01:29:01.420]                           break
[01:29:01.420]                         }
[01:29:01.420]                       }
[01:29:01.420]                     }
[01:29:01.420]                     invisible(muffled)
[01:29:01.420]                   }
[01:29:01.420]                   muffleCondition(cond)
[01:29:01.420]                 })
[01:29:01.420]             }))
[01:29:01.420]             future::FutureResult(value = ...future.value$value, 
[01:29:01.420]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:01.420]                   ...future.rng), globalenv = if (FALSE) 
[01:29:01.420]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:01.420]                     ...future.globalenv.names))
[01:29:01.420]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:01.420]         }, condition = base::local({
[01:29:01.420]             c <- base::c
[01:29:01.420]             inherits <- base::inherits
[01:29:01.420]             invokeRestart <- base::invokeRestart
[01:29:01.420]             length <- base::length
[01:29:01.420]             list <- base::list
[01:29:01.420]             seq.int <- base::seq.int
[01:29:01.420]             signalCondition <- base::signalCondition
[01:29:01.420]             sys.calls <- base::sys.calls
[01:29:01.420]             `[[` <- base::`[[`
[01:29:01.420]             `+` <- base::`+`
[01:29:01.420]             `<<-` <- base::`<<-`
[01:29:01.420]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:01.420]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:01.420]                   3L)]
[01:29:01.420]             }
[01:29:01.420]             function(cond) {
[01:29:01.420]                 is_error <- inherits(cond, "error")
[01:29:01.420]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:01.420]                   NULL)
[01:29:01.420]                 if (is_error) {
[01:29:01.420]                   sessionInformation <- function() {
[01:29:01.420]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:01.420]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:01.420]                       search = base::search(), system = base::Sys.info())
[01:29:01.420]                   }
[01:29:01.420]                   ...future.conditions[[length(...future.conditions) + 
[01:29:01.420]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:01.420]                     cond$call), session = sessionInformation(), 
[01:29:01.420]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:01.420]                   signalCondition(cond)
[01:29:01.420]                 }
[01:29:01.420]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:01.420]                 "immediateCondition"))) {
[01:29:01.420]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:01.420]                   ...future.conditions[[length(...future.conditions) + 
[01:29:01.420]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:01.420]                   if (TRUE && !signal) {
[01:29:01.420]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:01.420]                     {
[01:29:01.420]                       inherits <- base::inherits
[01:29:01.420]                       invokeRestart <- base::invokeRestart
[01:29:01.420]                       is.null <- base::is.null
[01:29:01.420]                       muffled <- FALSE
[01:29:01.420]                       if (inherits(cond, "message")) {
[01:29:01.420]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:01.420]                         if (muffled) 
[01:29:01.420]                           invokeRestart("muffleMessage")
[01:29:01.420]                       }
[01:29:01.420]                       else if (inherits(cond, "warning")) {
[01:29:01.420]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:01.420]                         if (muffled) 
[01:29:01.420]                           invokeRestart("muffleWarning")
[01:29:01.420]                       }
[01:29:01.420]                       else if (inherits(cond, "condition")) {
[01:29:01.420]                         if (!is.null(pattern)) {
[01:29:01.420]                           computeRestarts <- base::computeRestarts
[01:29:01.420]                           grepl <- base::grepl
[01:29:01.420]                           restarts <- computeRestarts(cond)
[01:29:01.420]                           for (restart in restarts) {
[01:29:01.420]                             name <- restart$name
[01:29:01.420]                             if (is.null(name)) 
[01:29:01.420]                               next
[01:29:01.420]                             if (!grepl(pattern, name)) 
[01:29:01.420]                               next
[01:29:01.420]                             invokeRestart(restart)
[01:29:01.420]                             muffled <- TRUE
[01:29:01.420]                             break
[01:29:01.420]                           }
[01:29:01.420]                         }
[01:29:01.420]                       }
[01:29:01.420]                       invisible(muffled)
[01:29:01.420]                     }
[01:29:01.420]                     muffleCondition(cond, pattern = "^muffle")
[01:29:01.420]                   }
[01:29:01.420]                 }
[01:29:01.420]                 else {
[01:29:01.420]                   if (TRUE) {
[01:29:01.420]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:01.420]                     {
[01:29:01.420]                       inherits <- base::inherits
[01:29:01.420]                       invokeRestart <- base::invokeRestart
[01:29:01.420]                       is.null <- base::is.null
[01:29:01.420]                       muffled <- FALSE
[01:29:01.420]                       if (inherits(cond, "message")) {
[01:29:01.420]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:01.420]                         if (muffled) 
[01:29:01.420]                           invokeRestart("muffleMessage")
[01:29:01.420]                       }
[01:29:01.420]                       else if (inherits(cond, "warning")) {
[01:29:01.420]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:01.420]                         if (muffled) 
[01:29:01.420]                           invokeRestart("muffleWarning")
[01:29:01.420]                       }
[01:29:01.420]                       else if (inherits(cond, "condition")) {
[01:29:01.420]                         if (!is.null(pattern)) {
[01:29:01.420]                           computeRestarts <- base::computeRestarts
[01:29:01.420]                           grepl <- base::grepl
[01:29:01.420]                           restarts <- computeRestarts(cond)
[01:29:01.420]                           for (restart in restarts) {
[01:29:01.420]                             name <- restart$name
[01:29:01.420]                             if (is.null(name)) 
[01:29:01.420]                               next
[01:29:01.420]                             if (!grepl(pattern, name)) 
[01:29:01.420]                               next
[01:29:01.420]                             invokeRestart(restart)
[01:29:01.420]                             muffled <- TRUE
[01:29:01.420]                             break
[01:29:01.420]                           }
[01:29:01.420]                         }
[01:29:01.420]                       }
[01:29:01.420]                       invisible(muffled)
[01:29:01.420]                     }
[01:29:01.420]                     muffleCondition(cond, pattern = "^muffle")
[01:29:01.420]                   }
[01:29:01.420]                 }
[01:29:01.420]             }
[01:29:01.420]         }))
[01:29:01.420]     }, error = function(ex) {
[01:29:01.420]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:01.420]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:01.420]                 ...future.rng), started = ...future.startTime, 
[01:29:01.420]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:01.420]             version = "1.8"), class = "FutureResult")
[01:29:01.420]     }, finally = {
[01:29:01.420]         if (!identical(...future.workdir, getwd())) 
[01:29:01.420]             setwd(...future.workdir)
[01:29:01.420]         {
[01:29:01.420]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:01.420]                 ...future.oldOptions$nwarnings <- NULL
[01:29:01.420]             }
[01:29:01.420]             base::options(...future.oldOptions)
[01:29:01.420]             if (.Platform$OS.type == "windows") {
[01:29:01.420]                 old_names <- names(...future.oldEnvVars)
[01:29:01.420]                 envs <- base::Sys.getenv()
[01:29:01.420]                 names <- names(envs)
[01:29:01.420]                 common <- intersect(names, old_names)
[01:29:01.420]                 added <- setdiff(names, old_names)
[01:29:01.420]                 removed <- setdiff(old_names, names)
[01:29:01.420]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:01.420]                   envs[common]]
[01:29:01.420]                 NAMES <- toupper(changed)
[01:29:01.420]                 args <- list()
[01:29:01.420]                 for (kk in seq_along(NAMES)) {
[01:29:01.420]                   name <- changed[[kk]]
[01:29:01.420]                   NAME <- NAMES[[kk]]
[01:29:01.420]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:01.420]                     next
[01:29:01.420]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:01.420]                 }
[01:29:01.420]                 NAMES <- toupper(added)
[01:29:01.420]                 for (kk in seq_along(NAMES)) {
[01:29:01.420]                   name <- added[[kk]]
[01:29:01.420]                   NAME <- NAMES[[kk]]
[01:29:01.420]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:01.420]                     next
[01:29:01.420]                   args[[name]] <- ""
[01:29:01.420]                 }
[01:29:01.420]                 NAMES <- toupper(removed)
[01:29:01.420]                 for (kk in seq_along(NAMES)) {
[01:29:01.420]                   name <- removed[[kk]]
[01:29:01.420]                   NAME <- NAMES[[kk]]
[01:29:01.420]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:01.420]                     next
[01:29:01.420]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:01.420]                 }
[01:29:01.420]                 if (length(args) > 0) 
[01:29:01.420]                   base::do.call(base::Sys.setenv, args = args)
[01:29:01.420]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:01.420]             }
[01:29:01.420]             else {
[01:29:01.420]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:01.420]             }
[01:29:01.420]             {
[01:29:01.420]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:01.420]                   0L) {
[01:29:01.420]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:01.420]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:01.420]                   base::options(opts)
[01:29:01.420]                 }
[01:29:01.420]                 {
[01:29:01.420]                   {
[01:29:01.420]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:01.420]                     NULL
[01:29:01.420]                   }
[01:29:01.420]                   options(future.plan = NULL)
[01:29:01.420]                   if (is.na(NA_character_)) 
[01:29:01.420]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:01.420]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:01.420]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:01.420]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:01.420]                     envir = parent.frame()) 
[01:29:01.420]                   {
[01:29:01.420]                     if (is.function(workers)) 
[01:29:01.420]                       workers <- workers()
[01:29:01.420]                     workers <- structure(as.integer(workers), 
[01:29:01.420]                       class = class(workers))
[01:29:01.420]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:01.420]                       workers >= 1)
[01:29:01.420]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:01.420]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:01.420]                     }
[01:29:01.420]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:01.420]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:01.420]                       envir = envir)
[01:29:01.420]                     if (!future$lazy) 
[01:29:01.420]                       future <- run(future)
[01:29:01.420]                     invisible(future)
[01:29:01.420]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:01.420]                 }
[01:29:01.420]             }
[01:29:01.420]         }
[01:29:01.420]     })
[01:29:01.420]     if (TRUE) {
[01:29:01.420]         base::sink(type = "output", split = FALSE)
[01:29:01.420]         if (TRUE) {
[01:29:01.420]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:01.420]         }
[01:29:01.420]         else {
[01:29:01.420]             ...future.result["stdout"] <- base::list(NULL)
[01:29:01.420]         }
[01:29:01.420]         base::close(...future.stdout)
[01:29:01.420]         ...future.stdout <- NULL
[01:29:01.420]     }
[01:29:01.420]     ...future.result$conditions <- ...future.conditions
[01:29:01.420]     ...future.result$finished <- base::Sys.time()
[01:29:01.420]     ...future.result
[01:29:01.420] }
[01:29:01.426] MultisessionFuture started
[01:29:01.426] - Launch lazy future ... done
[01:29:01.427] run() for 'MultisessionFuture' ... done
[01:29:01.445] receiveMessageFromWorker() for ClusterFuture ...
[01:29:01.445] - Validating connection of MultisessionFuture
[01:29:01.446] - received message: FutureResult
[01:29:01.446] - Received FutureResult
[01:29:01.446] - Erased future from FutureRegistry
[01:29:01.446] result() for ClusterFuture ...
[01:29:01.447] - result already collected: FutureResult
[01:29:01.447] result() for ClusterFuture ... done
[01:29:01.447] signalConditions() ...
[01:29:01.447]  - include = 'immediateCondition'
[01:29:01.447]  - exclude = 
[01:29:01.447]  - resignal = FALSE
[01:29:01.448]  - Number of conditions: 1
[01:29:01.448] signalConditions() ... done
[01:29:01.448] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:01.448] A MultisessionFuture was resolved (result was not collected)
- result = FALSE, recursive = 1 ... DONE
- result = FALSE, recursive = 2 ...
[01:29:01.448] getGlobalsAndPackages() ...
[01:29:01.449] Searching for globals...
[01:29:01.450] - globals found: [3] '{', 'Sys.sleep', 'list'
[01:29:01.450] Searching for globals ... DONE
[01:29:01.450] Resolving globals: FALSE
[01:29:01.451] 
[01:29:01.451] 
[01:29:01.451] getGlobalsAndPackages() ... DONE
[01:29:01.452] run() for 'Future' ...
[01:29:01.452] - state: 'created'
[01:29:01.452] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:01.466] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:01.466] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:01.466]   - Field: 'node'
[01:29:01.467]   - Field: 'label'
[01:29:01.467]   - Field: 'local'
[01:29:01.467]   - Field: 'owner'
[01:29:01.467]   - Field: 'envir'
[01:29:01.467]   - Field: 'workers'
[01:29:01.467]   - Field: 'packages'
[01:29:01.468]   - Field: 'gc'
[01:29:01.468]   - Field: 'conditions'
[01:29:01.468]   - Field: 'persistent'
[01:29:01.468]   - Field: 'expr'
[01:29:01.468]   - Field: 'uuid'
[01:29:01.469]   - Field: 'seed'
[01:29:01.469]   - Field: 'version'
[01:29:01.469]   - Field: 'result'
[01:29:01.469]   - Field: 'asynchronous'
[01:29:01.469]   - Field: 'calls'
[01:29:01.469]   - Field: 'globals'
[01:29:01.470]   - Field: 'stdout'
[01:29:01.470]   - Field: 'earlySignal'
[01:29:01.470]   - Field: 'lazy'
[01:29:01.470]   - Field: 'state'
[01:29:01.470] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:01.470] - Launch lazy future ...
[01:29:01.471] Packages needed by the future expression (n = 0): <none>
[01:29:01.471] Packages needed by future strategies (n = 0): <none>
[01:29:01.472] {
[01:29:01.472]     {
[01:29:01.472]         {
[01:29:01.472]             ...future.startTime <- base::Sys.time()
[01:29:01.472]             {
[01:29:01.472]                 {
[01:29:01.472]                   {
[01:29:01.472]                     {
[01:29:01.472]                       base::local({
[01:29:01.472]                         has_future <- base::requireNamespace("future", 
[01:29:01.472]                           quietly = TRUE)
[01:29:01.472]                         if (has_future) {
[01:29:01.472]                           ns <- base::getNamespace("future")
[01:29:01.472]                           version <- ns[[".package"]][["version"]]
[01:29:01.472]                           if (is.null(version)) 
[01:29:01.472]                             version <- utils::packageVersion("future")
[01:29:01.472]                         }
[01:29:01.472]                         else {
[01:29:01.472]                           version <- NULL
[01:29:01.472]                         }
[01:29:01.472]                         if (!has_future || version < "1.8.0") {
[01:29:01.472]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:01.472]                             "", base::R.version$version.string), 
[01:29:01.472]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:01.472]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:01.472]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:01.472]                               "release", "version")], collapse = " "), 
[01:29:01.472]                             hostname = base::Sys.info()[["nodename"]])
[01:29:01.472]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:01.472]                             info)
[01:29:01.472]                           info <- base::paste(info, collapse = "; ")
[01:29:01.472]                           if (!has_future) {
[01:29:01.472]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:01.472]                               info)
[01:29:01.472]                           }
[01:29:01.472]                           else {
[01:29:01.472]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:01.472]                               info, version)
[01:29:01.472]                           }
[01:29:01.472]                           base::stop(msg)
[01:29:01.472]                         }
[01:29:01.472]                       })
[01:29:01.472]                     }
[01:29:01.472]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:01.472]                     base::options(mc.cores = 1L)
[01:29:01.472]                   }
[01:29:01.472]                   options(future.plan = NULL)
[01:29:01.472]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:01.472]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:01.472]                 }
[01:29:01.472]                 ...future.workdir <- getwd()
[01:29:01.472]             }
[01:29:01.472]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:01.472]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:01.472]         }
[01:29:01.472]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:01.472]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:01.472]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:01.472]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:01.472]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:01.472]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:01.472]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:01.472]             base::names(...future.oldOptions))
[01:29:01.472]     }
[01:29:01.472]     if (FALSE) {
[01:29:01.472]     }
[01:29:01.472]     else {
[01:29:01.472]         if (TRUE) {
[01:29:01.472]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:01.472]                 open = "w")
[01:29:01.472]         }
[01:29:01.472]         else {
[01:29:01.472]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:01.472]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:01.472]         }
[01:29:01.472]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:01.472]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:01.472]             base::sink(type = "output", split = FALSE)
[01:29:01.472]             base::close(...future.stdout)
[01:29:01.472]         }, add = TRUE)
[01:29:01.472]     }
[01:29:01.472]     ...future.frame <- base::sys.nframe()
[01:29:01.472]     ...future.conditions <- base::list()
[01:29:01.472]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:01.472]     if (FALSE) {
[01:29:01.472]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:01.472]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:01.472]     }
[01:29:01.472]     ...future.result <- base::tryCatch({
[01:29:01.472]         base::withCallingHandlers({
[01:29:01.472]             ...future.value <- base::withVisible(base::local({
[01:29:01.472]                 ...future.makeSendCondition <- base::local({
[01:29:01.472]                   sendCondition <- NULL
[01:29:01.472]                   function(frame = 1L) {
[01:29:01.472]                     if (is.function(sendCondition)) 
[01:29:01.472]                       return(sendCondition)
[01:29:01.472]                     ns <- getNamespace("parallel")
[01:29:01.472]                     if (exists("sendData", mode = "function", 
[01:29:01.472]                       envir = ns)) {
[01:29:01.472]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:01.472]                         envir = ns)
[01:29:01.472]                       envir <- sys.frame(frame)
[01:29:01.472]                       master <- NULL
[01:29:01.472]                       while (!identical(envir, .GlobalEnv) && 
[01:29:01.472]                         !identical(envir, emptyenv())) {
[01:29:01.472]                         if (exists("master", mode = "list", envir = envir, 
[01:29:01.472]                           inherits = FALSE)) {
[01:29:01.472]                           master <- get("master", mode = "list", 
[01:29:01.472]                             envir = envir, inherits = FALSE)
[01:29:01.472]                           if (inherits(master, c("SOCKnode", 
[01:29:01.472]                             "SOCK0node"))) {
[01:29:01.472]                             sendCondition <<- function(cond) {
[01:29:01.472]                               data <- list(type = "VALUE", value = cond, 
[01:29:01.472]                                 success = TRUE)
[01:29:01.472]                               parallel_sendData(master, data)
[01:29:01.472]                             }
[01:29:01.472]                             return(sendCondition)
[01:29:01.472]                           }
[01:29:01.472]                         }
[01:29:01.472]                         frame <- frame + 1L
[01:29:01.472]                         envir <- sys.frame(frame)
[01:29:01.472]                       }
[01:29:01.472]                     }
[01:29:01.472]                     sendCondition <<- function(cond) NULL
[01:29:01.472]                   }
[01:29:01.472]                 })
[01:29:01.472]                 withCallingHandlers({
[01:29:01.472]                   {
[01:29:01.472]                     Sys.sleep(0.5)
[01:29:01.472]                     list(a = 1, b = 42L)
[01:29:01.472]                   }
[01:29:01.472]                 }, immediateCondition = function(cond) {
[01:29:01.472]                   sendCondition <- ...future.makeSendCondition()
[01:29:01.472]                   sendCondition(cond)
[01:29:01.472]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:01.472]                   {
[01:29:01.472]                     inherits <- base::inherits
[01:29:01.472]                     invokeRestart <- base::invokeRestart
[01:29:01.472]                     is.null <- base::is.null
[01:29:01.472]                     muffled <- FALSE
[01:29:01.472]                     if (inherits(cond, "message")) {
[01:29:01.472]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:01.472]                       if (muffled) 
[01:29:01.472]                         invokeRestart("muffleMessage")
[01:29:01.472]                     }
[01:29:01.472]                     else if (inherits(cond, "warning")) {
[01:29:01.472]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:01.472]                       if (muffled) 
[01:29:01.472]                         invokeRestart("muffleWarning")
[01:29:01.472]                     }
[01:29:01.472]                     else if (inherits(cond, "condition")) {
[01:29:01.472]                       if (!is.null(pattern)) {
[01:29:01.472]                         computeRestarts <- base::computeRestarts
[01:29:01.472]                         grepl <- base::grepl
[01:29:01.472]                         restarts <- computeRestarts(cond)
[01:29:01.472]                         for (restart in restarts) {
[01:29:01.472]                           name <- restart$name
[01:29:01.472]                           if (is.null(name)) 
[01:29:01.472]                             next
[01:29:01.472]                           if (!grepl(pattern, name)) 
[01:29:01.472]                             next
[01:29:01.472]                           invokeRestart(restart)
[01:29:01.472]                           muffled <- TRUE
[01:29:01.472]                           break
[01:29:01.472]                         }
[01:29:01.472]                       }
[01:29:01.472]                     }
[01:29:01.472]                     invisible(muffled)
[01:29:01.472]                   }
[01:29:01.472]                   muffleCondition(cond)
[01:29:01.472]                 })
[01:29:01.472]             }))
[01:29:01.472]             future::FutureResult(value = ...future.value$value, 
[01:29:01.472]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:01.472]                   ...future.rng), globalenv = if (FALSE) 
[01:29:01.472]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:01.472]                     ...future.globalenv.names))
[01:29:01.472]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:01.472]         }, condition = base::local({
[01:29:01.472]             c <- base::c
[01:29:01.472]             inherits <- base::inherits
[01:29:01.472]             invokeRestart <- base::invokeRestart
[01:29:01.472]             length <- base::length
[01:29:01.472]             list <- base::list
[01:29:01.472]             seq.int <- base::seq.int
[01:29:01.472]             signalCondition <- base::signalCondition
[01:29:01.472]             sys.calls <- base::sys.calls
[01:29:01.472]             `[[` <- base::`[[`
[01:29:01.472]             `+` <- base::`+`
[01:29:01.472]             `<<-` <- base::`<<-`
[01:29:01.472]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:01.472]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:01.472]                   3L)]
[01:29:01.472]             }
[01:29:01.472]             function(cond) {
[01:29:01.472]                 is_error <- inherits(cond, "error")
[01:29:01.472]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:01.472]                   NULL)
[01:29:01.472]                 if (is_error) {
[01:29:01.472]                   sessionInformation <- function() {
[01:29:01.472]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:01.472]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:01.472]                       search = base::search(), system = base::Sys.info())
[01:29:01.472]                   }
[01:29:01.472]                   ...future.conditions[[length(...future.conditions) + 
[01:29:01.472]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:01.472]                     cond$call), session = sessionInformation(), 
[01:29:01.472]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:01.472]                   signalCondition(cond)
[01:29:01.472]                 }
[01:29:01.472]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:01.472]                 "immediateCondition"))) {
[01:29:01.472]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:01.472]                   ...future.conditions[[length(...future.conditions) + 
[01:29:01.472]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:01.472]                   if (TRUE && !signal) {
[01:29:01.472]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:01.472]                     {
[01:29:01.472]                       inherits <- base::inherits
[01:29:01.472]                       invokeRestart <- base::invokeRestart
[01:29:01.472]                       is.null <- base::is.null
[01:29:01.472]                       muffled <- FALSE
[01:29:01.472]                       if (inherits(cond, "message")) {
[01:29:01.472]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:01.472]                         if (muffled) 
[01:29:01.472]                           invokeRestart("muffleMessage")
[01:29:01.472]                       }
[01:29:01.472]                       else if (inherits(cond, "warning")) {
[01:29:01.472]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:01.472]                         if (muffled) 
[01:29:01.472]                           invokeRestart("muffleWarning")
[01:29:01.472]                       }
[01:29:01.472]                       else if (inherits(cond, "condition")) {
[01:29:01.472]                         if (!is.null(pattern)) {
[01:29:01.472]                           computeRestarts <- base::computeRestarts
[01:29:01.472]                           grepl <- base::grepl
[01:29:01.472]                           restarts <- computeRestarts(cond)
[01:29:01.472]                           for (restart in restarts) {
[01:29:01.472]                             name <- restart$name
[01:29:01.472]                             if (is.null(name)) 
[01:29:01.472]                               next
[01:29:01.472]                             if (!grepl(pattern, name)) 
[01:29:01.472]                               next
[01:29:01.472]                             invokeRestart(restart)
[01:29:01.472]                             muffled <- TRUE
[01:29:01.472]                             break
[01:29:01.472]                           }
[01:29:01.472]                         }
[01:29:01.472]                       }
[01:29:01.472]                       invisible(muffled)
[01:29:01.472]                     }
[01:29:01.472]                     muffleCondition(cond, pattern = "^muffle")
[01:29:01.472]                   }
[01:29:01.472]                 }
[01:29:01.472]                 else {
[01:29:01.472]                   if (TRUE) {
[01:29:01.472]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:01.472]                     {
[01:29:01.472]                       inherits <- base::inherits
[01:29:01.472]                       invokeRestart <- base::invokeRestart
[01:29:01.472]                       is.null <- base::is.null
[01:29:01.472]                       muffled <- FALSE
[01:29:01.472]                       if (inherits(cond, "message")) {
[01:29:01.472]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:01.472]                         if (muffled) 
[01:29:01.472]                           invokeRestart("muffleMessage")
[01:29:01.472]                       }
[01:29:01.472]                       else if (inherits(cond, "warning")) {
[01:29:01.472]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:01.472]                         if (muffled) 
[01:29:01.472]                           invokeRestart("muffleWarning")
[01:29:01.472]                       }
[01:29:01.472]                       else if (inherits(cond, "condition")) {
[01:29:01.472]                         if (!is.null(pattern)) {
[01:29:01.472]                           computeRestarts <- base::computeRestarts
[01:29:01.472]                           grepl <- base::grepl
[01:29:01.472]                           restarts <- computeRestarts(cond)
[01:29:01.472]                           for (restart in restarts) {
[01:29:01.472]                             name <- restart$name
[01:29:01.472]                             if (is.null(name)) 
[01:29:01.472]                               next
[01:29:01.472]                             if (!grepl(pattern, name)) 
[01:29:01.472]                               next
[01:29:01.472]                             invokeRestart(restart)
[01:29:01.472]                             muffled <- TRUE
[01:29:01.472]                             break
[01:29:01.472]                           }
[01:29:01.472]                         }
[01:29:01.472]                       }
[01:29:01.472]                       invisible(muffled)
[01:29:01.472]                     }
[01:29:01.472]                     muffleCondition(cond, pattern = "^muffle")
[01:29:01.472]                   }
[01:29:01.472]                 }
[01:29:01.472]             }
[01:29:01.472]         }))
[01:29:01.472]     }, error = function(ex) {
[01:29:01.472]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:01.472]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:01.472]                 ...future.rng), started = ...future.startTime, 
[01:29:01.472]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:01.472]             version = "1.8"), class = "FutureResult")
[01:29:01.472]     }, finally = {
[01:29:01.472]         if (!identical(...future.workdir, getwd())) 
[01:29:01.472]             setwd(...future.workdir)
[01:29:01.472]         {
[01:29:01.472]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:01.472]                 ...future.oldOptions$nwarnings <- NULL
[01:29:01.472]             }
[01:29:01.472]             base::options(...future.oldOptions)
[01:29:01.472]             if (.Platform$OS.type == "windows") {
[01:29:01.472]                 old_names <- names(...future.oldEnvVars)
[01:29:01.472]                 envs <- base::Sys.getenv()
[01:29:01.472]                 names <- names(envs)
[01:29:01.472]                 common <- intersect(names, old_names)
[01:29:01.472]                 added <- setdiff(names, old_names)
[01:29:01.472]                 removed <- setdiff(old_names, names)
[01:29:01.472]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:01.472]                   envs[common]]
[01:29:01.472]                 NAMES <- toupper(changed)
[01:29:01.472]                 args <- list()
[01:29:01.472]                 for (kk in seq_along(NAMES)) {
[01:29:01.472]                   name <- changed[[kk]]
[01:29:01.472]                   NAME <- NAMES[[kk]]
[01:29:01.472]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:01.472]                     next
[01:29:01.472]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:01.472]                 }
[01:29:01.472]                 NAMES <- toupper(added)
[01:29:01.472]                 for (kk in seq_along(NAMES)) {
[01:29:01.472]                   name <- added[[kk]]
[01:29:01.472]                   NAME <- NAMES[[kk]]
[01:29:01.472]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:01.472]                     next
[01:29:01.472]                   args[[name]] <- ""
[01:29:01.472]                 }
[01:29:01.472]                 NAMES <- toupper(removed)
[01:29:01.472]                 for (kk in seq_along(NAMES)) {
[01:29:01.472]                   name <- removed[[kk]]
[01:29:01.472]                   NAME <- NAMES[[kk]]
[01:29:01.472]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:01.472]                     next
[01:29:01.472]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:01.472]                 }
[01:29:01.472]                 if (length(args) > 0) 
[01:29:01.472]                   base::do.call(base::Sys.setenv, args = args)
[01:29:01.472]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:01.472]             }
[01:29:01.472]             else {
[01:29:01.472]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:01.472]             }
[01:29:01.472]             {
[01:29:01.472]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:01.472]                   0L) {
[01:29:01.472]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:01.472]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:01.472]                   base::options(opts)
[01:29:01.472]                 }
[01:29:01.472]                 {
[01:29:01.472]                   {
[01:29:01.472]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:01.472]                     NULL
[01:29:01.472]                   }
[01:29:01.472]                   options(future.plan = NULL)
[01:29:01.472]                   if (is.na(NA_character_)) 
[01:29:01.472]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:01.472]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:01.472]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:01.472]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:01.472]                     envir = parent.frame()) 
[01:29:01.472]                   {
[01:29:01.472]                     if (is.function(workers)) 
[01:29:01.472]                       workers <- workers()
[01:29:01.472]                     workers <- structure(as.integer(workers), 
[01:29:01.472]                       class = class(workers))
[01:29:01.472]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:01.472]                       workers >= 1)
[01:29:01.472]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:01.472]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:01.472]                     }
[01:29:01.472]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:01.472]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:01.472]                       envir = envir)
[01:29:01.472]                     if (!future$lazy) 
[01:29:01.472]                       future <- run(future)
[01:29:01.472]                     invisible(future)
[01:29:01.472]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:01.472]                 }
[01:29:01.472]             }
[01:29:01.472]         }
[01:29:01.472]     })
[01:29:01.472]     if (TRUE) {
[01:29:01.472]         base::sink(type = "output", split = FALSE)
[01:29:01.472]         if (TRUE) {
[01:29:01.472]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:01.472]         }
[01:29:01.472]         else {
[01:29:01.472]             ...future.result["stdout"] <- base::list(NULL)
[01:29:01.472]         }
[01:29:01.472]         base::close(...future.stdout)
[01:29:01.472]         ...future.stdout <- NULL
[01:29:01.472]     }
[01:29:01.472]     ...future.result$conditions <- ...future.conditions
[01:29:01.472]     ...future.result$finished <- base::Sys.time()
[01:29:01.472]     ...future.result
[01:29:01.472] }
[01:29:01.477] MultisessionFuture started
[01:29:01.478] - Launch lazy future ... done
[01:29:01.478] run() for 'MultisessionFuture' ... done
[01:29:02.002] receiveMessageFromWorker() for ClusterFuture ...
[01:29:02.003] - Validating connection of MultisessionFuture
[01:29:02.003] - received message: FutureResult
[01:29:02.003] - Received FutureResult
[01:29:02.003] - Erased future from FutureRegistry
[01:29:02.004] result() for ClusterFuture ...
[01:29:02.004] - result already collected: FutureResult
[01:29:02.004] result() for ClusterFuture ... done
[01:29:02.004] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:02.004] A MultisessionFuture was resolved (result was not collected)
[01:29:02.004] getGlobalsAndPackages() ...
[01:29:02.005] Searching for globals...
[01:29:02.006] - globals found: [3] '{', 'Sys.sleep', 'list'
[01:29:02.006] Searching for globals ... DONE
[01:29:02.006] Resolving globals: FALSE
[01:29:02.007] 
[01:29:02.007] 
[01:29:02.007] getGlobalsAndPackages() ... DONE
[01:29:02.008] run() for 'Future' ...
[01:29:02.008] - state: 'created'
[01:29:02.008] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:02.023] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:02.023] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:02.023]   - Field: 'node'
[01:29:02.023]   - Field: 'label'
[01:29:02.023]   - Field: 'local'
[01:29:02.024]   - Field: 'owner'
[01:29:02.024]   - Field: 'envir'
[01:29:02.024]   - Field: 'workers'
[01:29:02.024]   - Field: 'packages'
[01:29:02.024]   - Field: 'gc'
[01:29:02.024]   - Field: 'conditions'
[01:29:02.025]   - Field: 'persistent'
[01:29:02.025]   - Field: 'expr'
[01:29:02.025]   - Field: 'uuid'
[01:29:02.025]   - Field: 'seed'
[01:29:02.025]   - Field: 'version'
[01:29:02.025]   - Field: 'result'
[01:29:02.026]   - Field: 'asynchronous'
[01:29:02.026]   - Field: 'calls'
[01:29:02.026]   - Field: 'globals'
[01:29:02.026]   - Field: 'stdout'
[01:29:02.026]   - Field: 'earlySignal'
[01:29:02.027]   - Field: 'lazy'
[01:29:02.027]   - Field: 'state'
[01:29:02.027] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:02.027] - Launch lazy future ...
[01:29:02.027] Packages needed by the future expression (n = 0): <none>
[01:29:02.028] Packages needed by future strategies (n = 0): <none>
[01:29:02.028] {
[01:29:02.028]     {
[01:29:02.028]         {
[01:29:02.028]             ...future.startTime <- base::Sys.time()
[01:29:02.028]             {
[01:29:02.028]                 {
[01:29:02.028]                   {
[01:29:02.028]                     {
[01:29:02.028]                       base::local({
[01:29:02.028]                         has_future <- base::requireNamespace("future", 
[01:29:02.028]                           quietly = TRUE)
[01:29:02.028]                         if (has_future) {
[01:29:02.028]                           ns <- base::getNamespace("future")
[01:29:02.028]                           version <- ns[[".package"]][["version"]]
[01:29:02.028]                           if (is.null(version)) 
[01:29:02.028]                             version <- utils::packageVersion("future")
[01:29:02.028]                         }
[01:29:02.028]                         else {
[01:29:02.028]                           version <- NULL
[01:29:02.028]                         }
[01:29:02.028]                         if (!has_future || version < "1.8.0") {
[01:29:02.028]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:02.028]                             "", base::R.version$version.string), 
[01:29:02.028]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:02.028]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:02.028]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:02.028]                               "release", "version")], collapse = " "), 
[01:29:02.028]                             hostname = base::Sys.info()[["nodename"]])
[01:29:02.028]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:02.028]                             info)
[01:29:02.028]                           info <- base::paste(info, collapse = "; ")
[01:29:02.028]                           if (!has_future) {
[01:29:02.028]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:02.028]                               info)
[01:29:02.028]                           }
[01:29:02.028]                           else {
[01:29:02.028]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:02.028]                               info, version)
[01:29:02.028]                           }
[01:29:02.028]                           base::stop(msg)
[01:29:02.028]                         }
[01:29:02.028]                       })
[01:29:02.028]                     }
[01:29:02.028]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:02.028]                     base::options(mc.cores = 1L)
[01:29:02.028]                   }
[01:29:02.028]                   options(future.plan = NULL)
[01:29:02.028]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:02.028]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:02.028]                 }
[01:29:02.028]                 ...future.workdir <- getwd()
[01:29:02.028]             }
[01:29:02.028]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:02.028]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:02.028]         }
[01:29:02.028]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:02.028]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:02.028]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:02.028]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:02.028]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:02.028]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:02.028]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:02.028]             base::names(...future.oldOptions))
[01:29:02.028]     }
[01:29:02.028]     if (FALSE) {
[01:29:02.028]     }
[01:29:02.028]     else {
[01:29:02.028]         if (TRUE) {
[01:29:02.028]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:02.028]                 open = "w")
[01:29:02.028]         }
[01:29:02.028]         else {
[01:29:02.028]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:02.028]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:02.028]         }
[01:29:02.028]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:02.028]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:02.028]             base::sink(type = "output", split = FALSE)
[01:29:02.028]             base::close(...future.stdout)
[01:29:02.028]         }, add = TRUE)
[01:29:02.028]     }
[01:29:02.028]     ...future.frame <- base::sys.nframe()
[01:29:02.028]     ...future.conditions <- base::list()
[01:29:02.028]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:02.028]     if (FALSE) {
[01:29:02.028]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:02.028]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:02.028]     }
[01:29:02.028]     ...future.result <- base::tryCatch({
[01:29:02.028]         base::withCallingHandlers({
[01:29:02.028]             ...future.value <- base::withVisible(base::local({
[01:29:02.028]                 ...future.makeSendCondition <- base::local({
[01:29:02.028]                   sendCondition <- NULL
[01:29:02.028]                   function(frame = 1L) {
[01:29:02.028]                     if (is.function(sendCondition)) 
[01:29:02.028]                       return(sendCondition)
[01:29:02.028]                     ns <- getNamespace("parallel")
[01:29:02.028]                     if (exists("sendData", mode = "function", 
[01:29:02.028]                       envir = ns)) {
[01:29:02.028]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:02.028]                         envir = ns)
[01:29:02.028]                       envir <- sys.frame(frame)
[01:29:02.028]                       master <- NULL
[01:29:02.028]                       while (!identical(envir, .GlobalEnv) && 
[01:29:02.028]                         !identical(envir, emptyenv())) {
[01:29:02.028]                         if (exists("master", mode = "list", envir = envir, 
[01:29:02.028]                           inherits = FALSE)) {
[01:29:02.028]                           master <- get("master", mode = "list", 
[01:29:02.028]                             envir = envir, inherits = FALSE)
[01:29:02.028]                           if (inherits(master, c("SOCKnode", 
[01:29:02.028]                             "SOCK0node"))) {
[01:29:02.028]                             sendCondition <<- function(cond) {
[01:29:02.028]                               data <- list(type = "VALUE", value = cond, 
[01:29:02.028]                                 success = TRUE)
[01:29:02.028]                               parallel_sendData(master, data)
[01:29:02.028]                             }
[01:29:02.028]                             return(sendCondition)
[01:29:02.028]                           }
[01:29:02.028]                         }
[01:29:02.028]                         frame <- frame + 1L
[01:29:02.028]                         envir <- sys.frame(frame)
[01:29:02.028]                       }
[01:29:02.028]                     }
[01:29:02.028]                     sendCondition <<- function(cond) NULL
[01:29:02.028]                   }
[01:29:02.028]                 })
[01:29:02.028]                 withCallingHandlers({
[01:29:02.028]                   {
[01:29:02.028]                     Sys.sleep(0.5)
[01:29:02.028]                     list(a = 1, b = 42L)
[01:29:02.028]                   }
[01:29:02.028]                 }, immediateCondition = function(cond) {
[01:29:02.028]                   sendCondition <- ...future.makeSendCondition()
[01:29:02.028]                   sendCondition(cond)
[01:29:02.028]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:02.028]                   {
[01:29:02.028]                     inherits <- base::inherits
[01:29:02.028]                     invokeRestart <- base::invokeRestart
[01:29:02.028]                     is.null <- base::is.null
[01:29:02.028]                     muffled <- FALSE
[01:29:02.028]                     if (inherits(cond, "message")) {
[01:29:02.028]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:02.028]                       if (muffled) 
[01:29:02.028]                         invokeRestart("muffleMessage")
[01:29:02.028]                     }
[01:29:02.028]                     else if (inherits(cond, "warning")) {
[01:29:02.028]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:02.028]                       if (muffled) 
[01:29:02.028]                         invokeRestart("muffleWarning")
[01:29:02.028]                     }
[01:29:02.028]                     else if (inherits(cond, "condition")) {
[01:29:02.028]                       if (!is.null(pattern)) {
[01:29:02.028]                         computeRestarts <- base::computeRestarts
[01:29:02.028]                         grepl <- base::grepl
[01:29:02.028]                         restarts <- computeRestarts(cond)
[01:29:02.028]                         for (restart in restarts) {
[01:29:02.028]                           name <- restart$name
[01:29:02.028]                           if (is.null(name)) 
[01:29:02.028]                             next
[01:29:02.028]                           if (!grepl(pattern, name)) 
[01:29:02.028]                             next
[01:29:02.028]                           invokeRestart(restart)
[01:29:02.028]                           muffled <- TRUE
[01:29:02.028]                           break
[01:29:02.028]                         }
[01:29:02.028]                       }
[01:29:02.028]                     }
[01:29:02.028]                     invisible(muffled)
[01:29:02.028]                   }
[01:29:02.028]                   muffleCondition(cond)
[01:29:02.028]                 })
[01:29:02.028]             }))
[01:29:02.028]             future::FutureResult(value = ...future.value$value, 
[01:29:02.028]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:02.028]                   ...future.rng), globalenv = if (FALSE) 
[01:29:02.028]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:02.028]                     ...future.globalenv.names))
[01:29:02.028]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:02.028]         }, condition = base::local({
[01:29:02.028]             c <- base::c
[01:29:02.028]             inherits <- base::inherits
[01:29:02.028]             invokeRestart <- base::invokeRestart
[01:29:02.028]             length <- base::length
[01:29:02.028]             list <- base::list
[01:29:02.028]             seq.int <- base::seq.int
[01:29:02.028]             signalCondition <- base::signalCondition
[01:29:02.028]             sys.calls <- base::sys.calls
[01:29:02.028]             `[[` <- base::`[[`
[01:29:02.028]             `+` <- base::`+`
[01:29:02.028]             `<<-` <- base::`<<-`
[01:29:02.028]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:02.028]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:02.028]                   3L)]
[01:29:02.028]             }
[01:29:02.028]             function(cond) {
[01:29:02.028]                 is_error <- inherits(cond, "error")
[01:29:02.028]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:02.028]                   NULL)
[01:29:02.028]                 if (is_error) {
[01:29:02.028]                   sessionInformation <- function() {
[01:29:02.028]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:02.028]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:02.028]                       search = base::search(), system = base::Sys.info())
[01:29:02.028]                   }
[01:29:02.028]                   ...future.conditions[[length(...future.conditions) + 
[01:29:02.028]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:02.028]                     cond$call), session = sessionInformation(), 
[01:29:02.028]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:02.028]                   signalCondition(cond)
[01:29:02.028]                 }
[01:29:02.028]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:02.028]                 "immediateCondition"))) {
[01:29:02.028]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:02.028]                   ...future.conditions[[length(...future.conditions) + 
[01:29:02.028]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:02.028]                   if (TRUE && !signal) {
[01:29:02.028]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:02.028]                     {
[01:29:02.028]                       inherits <- base::inherits
[01:29:02.028]                       invokeRestart <- base::invokeRestart
[01:29:02.028]                       is.null <- base::is.null
[01:29:02.028]                       muffled <- FALSE
[01:29:02.028]                       if (inherits(cond, "message")) {
[01:29:02.028]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:02.028]                         if (muffled) 
[01:29:02.028]                           invokeRestart("muffleMessage")
[01:29:02.028]                       }
[01:29:02.028]                       else if (inherits(cond, "warning")) {
[01:29:02.028]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:02.028]                         if (muffled) 
[01:29:02.028]                           invokeRestart("muffleWarning")
[01:29:02.028]                       }
[01:29:02.028]                       else if (inherits(cond, "condition")) {
[01:29:02.028]                         if (!is.null(pattern)) {
[01:29:02.028]                           computeRestarts <- base::computeRestarts
[01:29:02.028]                           grepl <- base::grepl
[01:29:02.028]                           restarts <- computeRestarts(cond)
[01:29:02.028]                           for (restart in restarts) {
[01:29:02.028]                             name <- restart$name
[01:29:02.028]                             if (is.null(name)) 
[01:29:02.028]                               next
[01:29:02.028]                             if (!grepl(pattern, name)) 
[01:29:02.028]                               next
[01:29:02.028]                             invokeRestart(restart)
[01:29:02.028]                             muffled <- TRUE
[01:29:02.028]                             break
[01:29:02.028]                           }
[01:29:02.028]                         }
[01:29:02.028]                       }
[01:29:02.028]                       invisible(muffled)
[01:29:02.028]                     }
[01:29:02.028]                     muffleCondition(cond, pattern = "^muffle")
[01:29:02.028]                   }
[01:29:02.028]                 }
[01:29:02.028]                 else {
[01:29:02.028]                   if (TRUE) {
[01:29:02.028]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:02.028]                     {
[01:29:02.028]                       inherits <- base::inherits
[01:29:02.028]                       invokeRestart <- base::invokeRestart
[01:29:02.028]                       is.null <- base::is.null
[01:29:02.028]                       muffled <- FALSE
[01:29:02.028]                       if (inherits(cond, "message")) {
[01:29:02.028]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:02.028]                         if (muffled) 
[01:29:02.028]                           invokeRestart("muffleMessage")
[01:29:02.028]                       }
[01:29:02.028]                       else if (inherits(cond, "warning")) {
[01:29:02.028]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:02.028]                         if (muffled) 
[01:29:02.028]                           invokeRestart("muffleWarning")
[01:29:02.028]                       }
[01:29:02.028]                       else if (inherits(cond, "condition")) {
[01:29:02.028]                         if (!is.null(pattern)) {
[01:29:02.028]                           computeRestarts <- base::computeRestarts
[01:29:02.028]                           grepl <- base::grepl
[01:29:02.028]                           restarts <- computeRestarts(cond)
[01:29:02.028]                           for (restart in restarts) {
[01:29:02.028]                             name <- restart$name
[01:29:02.028]                             if (is.null(name)) 
[01:29:02.028]                               next
[01:29:02.028]                             if (!grepl(pattern, name)) 
[01:29:02.028]                               next
[01:29:02.028]                             invokeRestart(restart)
[01:29:02.028]                             muffled <- TRUE
[01:29:02.028]                             break
[01:29:02.028]                           }
[01:29:02.028]                         }
[01:29:02.028]                       }
[01:29:02.028]                       invisible(muffled)
[01:29:02.028]                     }
[01:29:02.028]                     muffleCondition(cond, pattern = "^muffle")
[01:29:02.028]                   }
[01:29:02.028]                 }
[01:29:02.028]             }
[01:29:02.028]         }))
[01:29:02.028]     }, error = function(ex) {
[01:29:02.028]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:02.028]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:02.028]                 ...future.rng), started = ...future.startTime, 
[01:29:02.028]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:02.028]             version = "1.8"), class = "FutureResult")
[01:29:02.028]     }, finally = {
[01:29:02.028]         if (!identical(...future.workdir, getwd())) 
[01:29:02.028]             setwd(...future.workdir)
[01:29:02.028]         {
[01:29:02.028]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:02.028]                 ...future.oldOptions$nwarnings <- NULL
[01:29:02.028]             }
[01:29:02.028]             base::options(...future.oldOptions)
[01:29:02.028]             if (.Platform$OS.type == "windows") {
[01:29:02.028]                 old_names <- names(...future.oldEnvVars)
[01:29:02.028]                 envs <- base::Sys.getenv()
[01:29:02.028]                 names <- names(envs)
[01:29:02.028]                 common <- intersect(names, old_names)
[01:29:02.028]                 added <- setdiff(names, old_names)
[01:29:02.028]                 removed <- setdiff(old_names, names)
[01:29:02.028]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:02.028]                   envs[common]]
[01:29:02.028]                 NAMES <- toupper(changed)
[01:29:02.028]                 args <- list()
[01:29:02.028]                 for (kk in seq_along(NAMES)) {
[01:29:02.028]                   name <- changed[[kk]]
[01:29:02.028]                   NAME <- NAMES[[kk]]
[01:29:02.028]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:02.028]                     next
[01:29:02.028]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:02.028]                 }
[01:29:02.028]                 NAMES <- toupper(added)
[01:29:02.028]                 for (kk in seq_along(NAMES)) {
[01:29:02.028]                   name <- added[[kk]]
[01:29:02.028]                   NAME <- NAMES[[kk]]
[01:29:02.028]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:02.028]                     next
[01:29:02.028]                   args[[name]] <- ""
[01:29:02.028]                 }
[01:29:02.028]                 NAMES <- toupper(removed)
[01:29:02.028]                 for (kk in seq_along(NAMES)) {
[01:29:02.028]                   name <- removed[[kk]]
[01:29:02.028]                   NAME <- NAMES[[kk]]
[01:29:02.028]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:02.028]                     next
[01:29:02.028]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:02.028]                 }
[01:29:02.028]                 if (length(args) > 0) 
[01:29:02.028]                   base::do.call(base::Sys.setenv, args = args)
[01:29:02.028]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:02.028]             }
[01:29:02.028]             else {
[01:29:02.028]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:02.028]             }
[01:29:02.028]             {
[01:29:02.028]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:02.028]                   0L) {
[01:29:02.028]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:02.028]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:02.028]                   base::options(opts)
[01:29:02.028]                 }
[01:29:02.028]                 {
[01:29:02.028]                   {
[01:29:02.028]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:02.028]                     NULL
[01:29:02.028]                   }
[01:29:02.028]                   options(future.plan = NULL)
[01:29:02.028]                   if (is.na(NA_character_)) 
[01:29:02.028]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:02.028]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:02.028]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:02.028]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:02.028]                     envir = parent.frame()) 
[01:29:02.028]                   {
[01:29:02.028]                     if (is.function(workers)) 
[01:29:02.028]                       workers <- workers()
[01:29:02.028]                     workers <- structure(as.integer(workers), 
[01:29:02.028]                       class = class(workers))
[01:29:02.028]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:02.028]                       workers >= 1)
[01:29:02.028]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:02.028]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:02.028]                     }
[01:29:02.028]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:02.028]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:02.028]                       envir = envir)
[01:29:02.028]                     if (!future$lazy) 
[01:29:02.028]                       future <- run(future)
[01:29:02.028]                     invisible(future)
[01:29:02.028]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:02.028]                 }
[01:29:02.028]             }
[01:29:02.028]         }
[01:29:02.028]     })
[01:29:02.028]     if (TRUE) {
[01:29:02.028]         base::sink(type = "output", split = FALSE)
[01:29:02.028]         if (TRUE) {
[01:29:02.028]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:02.028]         }
[01:29:02.028]         else {
[01:29:02.028]             ...future.result["stdout"] <- base::list(NULL)
[01:29:02.028]         }
[01:29:02.028]         base::close(...future.stdout)
[01:29:02.028]         ...future.stdout <- NULL
[01:29:02.028]     }
[01:29:02.028]     ...future.result$conditions <- ...future.conditions
[01:29:02.028]     ...future.result$finished <- base::Sys.time()
[01:29:02.028]     ...future.result
[01:29:02.028] }
[01:29:02.034] MultisessionFuture started
[01:29:02.034] - Launch lazy future ... done
[01:29:02.035] run() for 'MultisessionFuture' ... done
[01:29:02.564] receiveMessageFromWorker() for ClusterFuture ...
[01:29:02.565] - Validating connection of MultisessionFuture
[01:29:02.565] - received message: FutureResult
[01:29:02.565] - Received FutureResult
[01:29:02.566] - Erased future from FutureRegistry
[01:29:02.566] result() for ClusterFuture ...
[01:29:02.566] - result already collected: FutureResult
[01:29:02.566] result() for ClusterFuture ... done
[01:29:02.566] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:02.566] A MultisessionFuture was resolved (result was not collected)
- w/ exception ...
[01:29:02.567] getGlobalsAndPackages() ...
[01:29:02.567] Searching for globals...
[01:29:02.568] - globals found: [2] 'list', 'stop'
[01:29:02.568] Searching for globals ... DONE
[01:29:02.568] Resolving globals: FALSE
[01:29:02.569] 
[01:29:02.569] 
[01:29:02.569] getGlobalsAndPackages() ... DONE
[01:29:02.569] run() for 'Future' ...
[01:29:02.570] - state: 'created'
[01:29:02.570] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:02.584] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:02.585] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:02.585]   - Field: 'node'
[01:29:02.585]   - Field: 'label'
[01:29:02.585]   - Field: 'local'
[01:29:02.585]   - Field: 'owner'
[01:29:02.585]   - Field: 'envir'
[01:29:02.586]   - Field: 'workers'
[01:29:02.586]   - Field: 'packages'
[01:29:02.586]   - Field: 'gc'
[01:29:02.586]   - Field: 'conditions'
[01:29:02.586]   - Field: 'persistent'
[01:29:02.587]   - Field: 'expr'
[01:29:02.587]   - Field: 'uuid'
[01:29:02.587]   - Field: 'seed'
[01:29:02.587]   - Field: 'version'
[01:29:02.587]   - Field: 'result'
[01:29:02.587]   - Field: 'asynchronous'
[01:29:02.588]   - Field: 'calls'
[01:29:02.588]   - Field: 'globals'
[01:29:02.588]   - Field: 'stdout'
[01:29:02.588]   - Field: 'earlySignal'
[01:29:02.588]   - Field: 'lazy'
[01:29:02.588]   - Field: 'state'
[01:29:02.589] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:02.589] - Launch lazy future ...
[01:29:02.589] Packages needed by the future expression (n = 0): <none>
[01:29:02.589] Packages needed by future strategies (n = 0): <none>
[01:29:02.590] {
[01:29:02.590]     {
[01:29:02.590]         {
[01:29:02.590]             ...future.startTime <- base::Sys.time()
[01:29:02.590]             {
[01:29:02.590]                 {
[01:29:02.590]                   {
[01:29:02.590]                     {
[01:29:02.590]                       base::local({
[01:29:02.590]                         has_future <- base::requireNamespace("future", 
[01:29:02.590]                           quietly = TRUE)
[01:29:02.590]                         if (has_future) {
[01:29:02.590]                           ns <- base::getNamespace("future")
[01:29:02.590]                           version <- ns[[".package"]][["version"]]
[01:29:02.590]                           if (is.null(version)) 
[01:29:02.590]                             version <- utils::packageVersion("future")
[01:29:02.590]                         }
[01:29:02.590]                         else {
[01:29:02.590]                           version <- NULL
[01:29:02.590]                         }
[01:29:02.590]                         if (!has_future || version < "1.8.0") {
[01:29:02.590]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:02.590]                             "", base::R.version$version.string), 
[01:29:02.590]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:02.590]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:02.590]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:02.590]                               "release", "version")], collapse = " "), 
[01:29:02.590]                             hostname = base::Sys.info()[["nodename"]])
[01:29:02.590]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:02.590]                             info)
[01:29:02.590]                           info <- base::paste(info, collapse = "; ")
[01:29:02.590]                           if (!has_future) {
[01:29:02.590]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:02.590]                               info)
[01:29:02.590]                           }
[01:29:02.590]                           else {
[01:29:02.590]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:02.590]                               info, version)
[01:29:02.590]                           }
[01:29:02.590]                           base::stop(msg)
[01:29:02.590]                         }
[01:29:02.590]                       })
[01:29:02.590]                     }
[01:29:02.590]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:02.590]                     base::options(mc.cores = 1L)
[01:29:02.590]                   }
[01:29:02.590]                   options(future.plan = NULL)
[01:29:02.590]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:02.590]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:02.590]                 }
[01:29:02.590]                 ...future.workdir <- getwd()
[01:29:02.590]             }
[01:29:02.590]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:02.590]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:02.590]         }
[01:29:02.590]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:02.590]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:02.590]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:02.590]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:02.590]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:02.590]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:02.590]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:02.590]             base::names(...future.oldOptions))
[01:29:02.590]     }
[01:29:02.590]     if (FALSE) {
[01:29:02.590]     }
[01:29:02.590]     else {
[01:29:02.590]         if (TRUE) {
[01:29:02.590]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:02.590]                 open = "w")
[01:29:02.590]         }
[01:29:02.590]         else {
[01:29:02.590]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:02.590]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:02.590]         }
[01:29:02.590]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:02.590]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:02.590]             base::sink(type = "output", split = FALSE)
[01:29:02.590]             base::close(...future.stdout)
[01:29:02.590]         }, add = TRUE)
[01:29:02.590]     }
[01:29:02.590]     ...future.frame <- base::sys.nframe()
[01:29:02.590]     ...future.conditions <- base::list()
[01:29:02.590]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:02.590]     if (FALSE) {
[01:29:02.590]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:02.590]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:02.590]     }
[01:29:02.590]     ...future.result <- base::tryCatch({
[01:29:02.590]         base::withCallingHandlers({
[01:29:02.590]             ...future.value <- base::withVisible(base::local({
[01:29:02.590]                 ...future.makeSendCondition <- base::local({
[01:29:02.590]                   sendCondition <- NULL
[01:29:02.590]                   function(frame = 1L) {
[01:29:02.590]                     if (is.function(sendCondition)) 
[01:29:02.590]                       return(sendCondition)
[01:29:02.590]                     ns <- getNamespace("parallel")
[01:29:02.590]                     if (exists("sendData", mode = "function", 
[01:29:02.590]                       envir = ns)) {
[01:29:02.590]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:02.590]                         envir = ns)
[01:29:02.590]                       envir <- sys.frame(frame)
[01:29:02.590]                       master <- NULL
[01:29:02.590]                       while (!identical(envir, .GlobalEnv) && 
[01:29:02.590]                         !identical(envir, emptyenv())) {
[01:29:02.590]                         if (exists("master", mode = "list", envir = envir, 
[01:29:02.590]                           inherits = FALSE)) {
[01:29:02.590]                           master <- get("master", mode = "list", 
[01:29:02.590]                             envir = envir, inherits = FALSE)
[01:29:02.590]                           if (inherits(master, c("SOCKnode", 
[01:29:02.590]                             "SOCK0node"))) {
[01:29:02.590]                             sendCondition <<- function(cond) {
[01:29:02.590]                               data <- list(type = "VALUE", value = cond, 
[01:29:02.590]                                 success = TRUE)
[01:29:02.590]                               parallel_sendData(master, data)
[01:29:02.590]                             }
[01:29:02.590]                             return(sendCondition)
[01:29:02.590]                           }
[01:29:02.590]                         }
[01:29:02.590]                         frame <- frame + 1L
[01:29:02.590]                         envir <- sys.frame(frame)
[01:29:02.590]                       }
[01:29:02.590]                     }
[01:29:02.590]                     sendCondition <<- function(cond) NULL
[01:29:02.590]                   }
[01:29:02.590]                 })
[01:29:02.590]                 withCallingHandlers({
[01:29:02.590]                   list(a = 1, b = 42L, c = stop("Nah!"))
[01:29:02.590]                 }, immediateCondition = function(cond) {
[01:29:02.590]                   sendCondition <- ...future.makeSendCondition()
[01:29:02.590]                   sendCondition(cond)
[01:29:02.590]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:02.590]                   {
[01:29:02.590]                     inherits <- base::inherits
[01:29:02.590]                     invokeRestart <- base::invokeRestart
[01:29:02.590]                     is.null <- base::is.null
[01:29:02.590]                     muffled <- FALSE
[01:29:02.590]                     if (inherits(cond, "message")) {
[01:29:02.590]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:02.590]                       if (muffled) 
[01:29:02.590]                         invokeRestart("muffleMessage")
[01:29:02.590]                     }
[01:29:02.590]                     else if (inherits(cond, "warning")) {
[01:29:02.590]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:02.590]                       if (muffled) 
[01:29:02.590]                         invokeRestart("muffleWarning")
[01:29:02.590]                     }
[01:29:02.590]                     else if (inherits(cond, "condition")) {
[01:29:02.590]                       if (!is.null(pattern)) {
[01:29:02.590]                         computeRestarts <- base::computeRestarts
[01:29:02.590]                         grepl <- base::grepl
[01:29:02.590]                         restarts <- computeRestarts(cond)
[01:29:02.590]                         for (restart in restarts) {
[01:29:02.590]                           name <- restart$name
[01:29:02.590]                           if (is.null(name)) 
[01:29:02.590]                             next
[01:29:02.590]                           if (!grepl(pattern, name)) 
[01:29:02.590]                             next
[01:29:02.590]                           invokeRestart(restart)
[01:29:02.590]                           muffled <- TRUE
[01:29:02.590]                           break
[01:29:02.590]                         }
[01:29:02.590]                       }
[01:29:02.590]                     }
[01:29:02.590]                     invisible(muffled)
[01:29:02.590]                   }
[01:29:02.590]                   muffleCondition(cond)
[01:29:02.590]                 })
[01:29:02.590]             }))
[01:29:02.590]             future::FutureResult(value = ...future.value$value, 
[01:29:02.590]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:02.590]                   ...future.rng), globalenv = if (FALSE) 
[01:29:02.590]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:02.590]                     ...future.globalenv.names))
[01:29:02.590]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:02.590]         }, condition = base::local({
[01:29:02.590]             c <- base::c
[01:29:02.590]             inherits <- base::inherits
[01:29:02.590]             invokeRestart <- base::invokeRestart
[01:29:02.590]             length <- base::length
[01:29:02.590]             list <- base::list
[01:29:02.590]             seq.int <- base::seq.int
[01:29:02.590]             signalCondition <- base::signalCondition
[01:29:02.590]             sys.calls <- base::sys.calls
[01:29:02.590]             `[[` <- base::`[[`
[01:29:02.590]             `+` <- base::`+`
[01:29:02.590]             `<<-` <- base::`<<-`
[01:29:02.590]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:02.590]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:02.590]                   3L)]
[01:29:02.590]             }
[01:29:02.590]             function(cond) {
[01:29:02.590]                 is_error <- inherits(cond, "error")
[01:29:02.590]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:02.590]                   NULL)
[01:29:02.590]                 if (is_error) {
[01:29:02.590]                   sessionInformation <- function() {
[01:29:02.590]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:02.590]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:02.590]                       search = base::search(), system = base::Sys.info())
[01:29:02.590]                   }
[01:29:02.590]                   ...future.conditions[[length(...future.conditions) + 
[01:29:02.590]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:02.590]                     cond$call), session = sessionInformation(), 
[01:29:02.590]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:02.590]                   signalCondition(cond)
[01:29:02.590]                 }
[01:29:02.590]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:02.590]                 "immediateCondition"))) {
[01:29:02.590]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:02.590]                   ...future.conditions[[length(...future.conditions) + 
[01:29:02.590]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:02.590]                   if (TRUE && !signal) {
[01:29:02.590]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:02.590]                     {
[01:29:02.590]                       inherits <- base::inherits
[01:29:02.590]                       invokeRestart <- base::invokeRestart
[01:29:02.590]                       is.null <- base::is.null
[01:29:02.590]                       muffled <- FALSE
[01:29:02.590]                       if (inherits(cond, "message")) {
[01:29:02.590]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:02.590]                         if (muffled) 
[01:29:02.590]                           invokeRestart("muffleMessage")
[01:29:02.590]                       }
[01:29:02.590]                       else if (inherits(cond, "warning")) {
[01:29:02.590]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:02.590]                         if (muffled) 
[01:29:02.590]                           invokeRestart("muffleWarning")
[01:29:02.590]                       }
[01:29:02.590]                       else if (inherits(cond, "condition")) {
[01:29:02.590]                         if (!is.null(pattern)) {
[01:29:02.590]                           computeRestarts <- base::computeRestarts
[01:29:02.590]                           grepl <- base::grepl
[01:29:02.590]                           restarts <- computeRestarts(cond)
[01:29:02.590]                           for (restart in restarts) {
[01:29:02.590]                             name <- restart$name
[01:29:02.590]                             if (is.null(name)) 
[01:29:02.590]                               next
[01:29:02.590]                             if (!grepl(pattern, name)) 
[01:29:02.590]                               next
[01:29:02.590]                             invokeRestart(restart)
[01:29:02.590]                             muffled <- TRUE
[01:29:02.590]                             break
[01:29:02.590]                           }
[01:29:02.590]                         }
[01:29:02.590]                       }
[01:29:02.590]                       invisible(muffled)
[01:29:02.590]                     }
[01:29:02.590]                     muffleCondition(cond, pattern = "^muffle")
[01:29:02.590]                   }
[01:29:02.590]                 }
[01:29:02.590]                 else {
[01:29:02.590]                   if (TRUE) {
[01:29:02.590]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:02.590]                     {
[01:29:02.590]                       inherits <- base::inherits
[01:29:02.590]                       invokeRestart <- base::invokeRestart
[01:29:02.590]                       is.null <- base::is.null
[01:29:02.590]                       muffled <- FALSE
[01:29:02.590]                       if (inherits(cond, "message")) {
[01:29:02.590]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:02.590]                         if (muffled) 
[01:29:02.590]                           invokeRestart("muffleMessage")
[01:29:02.590]                       }
[01:29:02.590]                       else if (inherits(cond, "warning")) {
[01:29:02.590]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:02.590]                         if (muffled) 
[01:29:02.590]                           invokeRestart("muffleWarning")
[01:29:02.590]                       }
[01:29:02.590]                       else if (inherits(cond, "condition")) {
[01:29:02.590]                         if (!is.null(pattern)) {
[01:29:02.590]                           computeRestarts <- base::computeRestarts
[01:29:02.590]                           grepl <- base::grepl
[01:29:02.590]                           restarts <- computeRestarts(cond)
[01:29:02.590]                           for (restart in restarts) {
[01:29:02.590]                             name <- restart$name
[01:29:02.590]                             if (is.null(name)) 
[01:29:02.590]                               next
[01:29:02.590]                             if (!grepl(pattern, name)) 
[01:29:02.590]                               next
[01:29:02.590]                             invokeRestart(restart)
[01:29:02.590]                             muffled <- TRUE
[01:29:02.590]                             break
[01:29:02.590]                           }
[01:29:02.590]                         }
[01:29:02.590]                       }
[01:29:02.590]                       invisible(muffled)
[01:29:02.590]                     }
[01:29:02.590]                     muffleCondition(cond, pattern = "^muffle")
[01:29:02.590]                   }
[01:29:02.590]                 }
[01:29:02.590]             }
[01:29:02.590]         }))
[01:29:02.590]     }, error = function(ex) {
[01:29:02.590]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:02.590]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:02.590]                 ...future.rng), started = ...future.startTime, 
[01:29:02.590]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:02.590]             version = "1.8"), class = "FutureResult")
[01:29:02.590]     }, finally = {
[01:29:02.590]         if (!identical(...future.workdir, getwd())) 
[01:29:02.590]             setwd(...future.workdir)
[01:29:02.590]         {
[01:29:02.590]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:02.590]                 ...future.oldOptions$nwarnings <- NULL
[01:29:02.590]             }
[01:29:02.590]             base::options(...future.oldOptions)
[01:29:02.590]             if (.Platform$OS.type == "windows") {
[01:29:02.590]                 old_names <- names(...future.oldEnvVars)
[01:29:02.590]                 envs <- base::Sys.getenv()
[01:29:02.590]                 names <- names(envs)
[01:29:02.590]                 common <- intersect(names, old_names)
[01:29:02.590]                 added <- setdiff(names, old_names)
[01:29:02.590]                 removed <- setdiff(old_names, names)
[01:29:02.590]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:02.590]                   envs[common]]
[01:29:02.590]                 NAMES <- toupper(changed)
[01:29:02.590]                 args <- list()
[01:29:02.590]                 for (kk in seq_along(NAMES)) {
[01:29:02.590]                   name <- changed[[kk]]
[01:29:02.590]                   NAME <- NAMES[[kk]]
[01:29:02.590]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:02.590]                     next
[01:29:02.590]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:02.590]                 }
[01:29:02.590]                 NAMES <- toupper(added)
[01:29:02.590]                 for (kk in seq_along(NAMES)) {
[01:29:02.590]                   name <- added[[kk]]
[01:29:02.590]                   NAME <- NAMES[[kk]]
[01:29:02.590]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:02.590]                     next
[01:29:02.590]                   args[[name]] <- ""
[01:29:02.590]                 }
[01:29:02.590]                 NAMES <- toupper(removed)
[01:29:02.590]                 for (kk in seq_along(NAMES)) {
[01:29:02.590]                   name <- removed[[kk]]
[01:29:02.590]                   NAME <- NAMES[[kk]]
[01:29:02.590]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:02.590]                     next
[01:29:02.590]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:02.590]                 }
[01:29:02.590]                 if (length(args) > 0) 
[01:29:02.590]                   base::do.call(base::Sys.setenv, args = args)
[01:29:02.590]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:02.590]             }
[01:29:02.590]             else {
[01:29:02.590]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:02.590]             }
[01:29:02.590]             {
[01:29:02.590]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:02.590]                   0L) {
[01:29:02.590]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:02.590]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:02.590]                   base::options(opts)
[01:29:02.590]                 }
[01:29:02.590]                 {
[01:29:02.590]                   {
[01:29:02.590]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:02.590]                     NULL
[01:29:02.590]                   }
[01:29:02.590]                   options(future.plan = NULL)
[01:29:02.590]                   if (is.na(NA_character_)) 
[01:29:02.590]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:02.590]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:02.590]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:02.590]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:02.590]                     envir = parent.frame()) 
[01:29:02.590]                   {
[01:29:02.590]                     if (is.function(workers)) 
[01:29:02.590]                       workers <- workers()
[01:29:02.590]                     workers <- structure(as.integer(workers), 
[01:29:02.590]                       class = class(workers))
[01:29:02.590]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:02.590]                       workers >= 1)
[01:29:02.590]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:02.590]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:02.590]                     }
[01:29:02.590]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:02.590]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:02.590]                       envir = envir)
[01:29:02.590]                     if (!future$lazy) 
[01:29:02.590]                       future <- run(future)
[01:29:02.590]                     invisible(future)
[01:29:02.590]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:02.590]                 }
[01:29:02.590]             }
[01:29:02.590]         }
[01:29:02.590]     })
[01:29:02.590]     if (TRUE) {
[01:29:02.590]         base::sink(type = "output", split = FALSE)
[01:29:02.590]         if (TRUE) {
[01:29:02.590]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:02.590]         }
[01:29:02.590]         else {
[01:29:02.590]             ...future.result["stdout"] <- base::list(NULL)
[01:29:02.590]         }
[01:29:02.590]         base::close(...future.stdout)
[01:29:02.590]         ...future.stdout <- NULL
[01:29:02.590]     }
[01:29:02.590]     ...future.result$conditions <- ...future.conditions
[01:29:02.590]     ...future.result$finished <- base::Sys.time()
[01:29:02.590]     ...future.result
[01:29:02.590] }
[01:29:02.596] MultisessionFuture started
[01:29:02.596] - Launch lazy future ... done
[01:29:02.596] run() for 'MultisessionFuture' ... done
[01:29:02.613] receiveMessageFromWorker() for ClusterFuture ...
[01:29:02.613] - Validating connection of MultisessionFuture
[01:29:02.614] - received message: FutureResult
[01:29:02.614] - Received FutureResult
[01:29:02.614] - Erased future from FutureRegistry
[01:29:02.614] result() for ClusterFuture ...
[01:29:02.614] - result already collected: FutureResult
[01:29:02.615] result() for ClusterFuture ... done
[01:29:02.615] signalConditions() ...
[01:29:02.615]  - include = 'immediateCondition'
[01:29:02.615]  - exclude = 
[01:29:02.615]  - resignal = FALSE
[01:29:02.615]  - Number of conditions: 1
[01:29:02.616] signalConditions() ... done
[01:29:02.616] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:02.616] A MultisessionFuture was resolved (result was not collected)
[01:29:02.616] getGlobalsAndPackages() ...
[01:29:02.616] Searching for globals...
[01:29:02.617] - globals found: [2] 'list', 'stop'
[01:29:02.617] Searching for globals ... DONE
[01:29:02.617] Resolving globals: FALSE
[01:29:02.618] 
[01:29:02.618] 
[01:29:02.618] getGlobalsAndPackages() ... DONE
[01:29:02.619] run() for 'Future' ...
[01:29:02.619] - state: 'created'
[01:29:02.619] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:02.633] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:02.634] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:02.634]   - Field: 'node'
[01:29:02.634]   - Field: 'label'
[01:29:02.634]   - Field: 'local'
[01:29:02.634]   - Field: 'owner'
[01:29:02.634]   - Field: 'envir'
[01:29:02.635]   - Field: 'workers'
[01:29:02.635]   - Field: 'packages'
[01:29:02.635]   - Field: 'gc'
[01:29:02.635]   - Field: 'conditions'
[01:29:02.635]   - Field: 'persistent'
[01:29:02.636]   - Field: 'expr'
[01:29:02.636]   - Field: 'uuid'
[01:29:02.636]   - Field: 'seed'
[01:29:02.636]   - Field: 'version'
[01:29:02.636]   - Field: 'result'
[01:29:02.636]   - Field: 'asynchronous'
[01:29:02.637]   - Field: 'calls'
[01:29:02.637]   - Field: 'globals'
[01:29:02.637]   - Field: 'stdout'
[01:29:02.637]   - Field: 'earlySignal'
[01:29:02.637]   - Field: 'lazy'
[01:29:02.637]   - Field: 'state'
[01:29:02.638] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:02.638] - Launch lazy future ...
[01:29:02.638] Packages needed by the future expression (n = 0): <none>
[01:29:02.638] Packages needed by future strategies (n = 0): <none>
[01:29:02.639] {
[01:29:02.639]     {
[01:29:02.639]         {
[01:29:02.639]             ...future.startTime <- base::Sys.time()
[01:29:02.639]             {
[01:29:02.639]                 {
[01:29:02.639]                   {
[01:29:02.639]                     {
[01:29:02.639]                       base::local({
[01:29:02.639]                         has_future <- base::requireNamespace("future", 
[01:29:02.639]                           quietly = TRUE)
[01:29:02.639]                         if (has_future) {
[01:29:02.639]                           ns <- base::getNamespace("future")
[01:29:02.639]                           version <- ns[[".package"]][["version"]]
[01:29:02.639]                           if (is.null(version)) 
[01:29:02.639]                             version <- utils::packageVersion("future")
[01:29:02.639]                         }
[01:29:02.639]                         else {
[01:29:02.639]                           version <- NULL
[01:29:02.639]                         }
[01:29:02.639]                         if (!has_future || version < "1.8.0") {
[01:29:02.639]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:02.639]                             "", base::R.version$version.string), 
[01:29:02.639]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:02.639]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:02.639]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:02.639]                               "release", "version")], collapse = " "), 
[01:29:02.639]                             hostname = base::Sys.info()[["nodename"]])
[01:29:02.639]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:02.639]                             info)
[01:29:02.639]                           info <- base::paste(info, collapse = "; ")
[01:29:02.639]                           if (!has_future) {
[01:29:02.639]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:02.639]                               info)
[01:29:02.639]                           }
[01:29:02.639]                           else {
[01:29:02.639]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:02.639]                               info, version)
[01:29:02.639]                           }
[01:29:02.639]                           base::stop(msg)
[01:29:02.639]                         }
[01:29:02.639]                       })
[01:29:02.639]                     }
[01:29:02.639]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:02.639]                     base::options(mc.cores = 1L)
[01:29:02.639]                   }
[01:29:02.639]                   options(future.plan = NULL)
[01:29:02.639]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:02.639]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:02.639]                 }
[01:29:02.639]                 ...future.workdir <- getwd()
[01:29:02.639]             }
[01:29:02.639]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:02.639]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:02.639]         }
[01:29:02.639]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:02.639]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:02.639]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:02.639]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:02.639]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:02.639]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:02.639]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:02.639]             base::names(...future.oldOptions))
[01:29:02.639]     }
[01:29:02.639]     if (FALSE) {
[01:29:02.639]     }
[01:29:02.639]     else {
[01:29:02.639]         if (TRUE) {
[01:29:02.639]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:02.639]                 open = "w")
[01:29:02.639]         }
[01:29:02.639]         else {
[01:29:02.639]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:02.639]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:02.639]         }
[01:29:02.639]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:02.639]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:02.639]             base::sink(type = "output", split = FALSE)
[01:29:02.639]             base::close(...future.stdout)
[01:29:02.639]         }, add = TRUE)
[01:29:02.639]     }
[01:29:02.639]     ...future.frame <- base::sys.nframe()
[01:29:02.639]     ...future.conditions <- base::list()
[01:29:02.639]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:02.639]     if (FALSE) {
[01:29:02.639]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:02.639]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:02.639]     }
[01:29:02.639]     ...future.result <- base::tryCatch({
[01:29:02.639]         base::withCallingHandlers({
[01:29:02.639]             ...future.value <- base::withVisible(base::local({
[01:29:02.639]                 ...future.makeSendCondition <- base::local({
[01:29:02.639]                   sendCondition <- NULL
[01:29:02.639]                   function(frame = 1L) {
[01:29:02.639]                     if (is.function(sendCondition)) 
[01:29:02.639]                       return(sendCondition)
[01:29:02.639]                     ns <- getNamespace("parallel")
[01:29:02.639]                     if (exists("sendData", mode = "function", 
[01:29:02.639]                       envir = ns)) {
[01:29:02.639]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:02.639]                         envir = ns)
[01:29:02.639]                       envir <- sys.frame(frame)
[01:29:02.639]                       master <- NULL
[01:29:02.639]                       while (!identical(envir, .GlobalEnv) && 
[01:29:02.639]                         !identical(envir, emptyenv())) {
[01:29:02.639]                         if (exists("master", mode = "list", envir = envir, 
[01:29:02.639]                           inherits = FALSE)) {
[01:29:02.639]                           master <- get("master", mode = "list", 
[01:29:02.639]                             envir = envir, inherits = FALSE)
[01:29:02.639]                           if (inherits(master, c("SOCKnode", 
[01:29:02.639]                             "SOCK0node"))) {
[01:29:02.639]                             sendCondition <<- function(cond) {
[01:29:02.639]                               data <- list(type = "VALUE", value = cond, 
[01:29:02.639]                                 success = TRUE)
[01:29:02.639]                               parallel_sendData(master, data)
[01:29:02.639]                             }
[01:29:02.639]                             return(sendCondition)
[01:29:02.639]                           }
[01:29:02.639]                         }
[01:29:02.639]                         frame <- frame + 1L
[01:29:02.639]                         envir <- sys.frame(frame)
[01:29:02.639]                       }
[01:29:02.639]                     }
[01:29:02.639]                     sendCondition <<- function(cond) NULL
[01:29:02.639]                   }
[01:29:02.639]                 })
[01:29:02.639]                 withCallingHandlers({
[01:29:02.639]                   list(a = 1, b = 42L, c = stop("Nah!"))
[01:29:02.639]                 }, immediateCondition = function(cond) {
[01:29:02.639]                   sendCondition <- ...future.makeSendCondition()
[01:29:02.639]                   sendCondition(cond)
[01:29:02.639]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:02.639]                   {
[01:29:02.639]                     inherits <- base::inherits
[01:29:02.639]                     invokeRestart <- base::invokeRestart
[01:29:02.639]                     is.null <- base::is.null
[01:29:02.639]                     muffled <- FALSE
[01:29:02.639]                     if (inherits(cond, "message")) {
[01:29:02.639]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:02.639]                       if (muffled) 
[01:29:02.639]                         invokeRestart("muffleMessage")
[01:29:02.639]                     }
[01:29:02.639]                     else if (inherits(cond, "warning")) {
[01:29:02.639]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:02.639]                       if (muffled) 
[01:29:02.639]                         invokeRestart("muffleWarning")
[01:29:02.639]                     }
[01:29:02.639]                     else if (inherits(cond, "condition")) {
[01:29:02.639]                       if (!is.null(pattern)) {
[01:29:02.639]                         computeRestarts <- base::computeRestarts
[01:29:02.639]                         grepl <- base::grepl
[01:29:02.639]                         restarts <- computeRestarts(cond)
[01:29:02.639]                         for (restart in restarts) {
[01:29:02.639]                           name <- restart$name
[01:29:02.639]                           if (is.null(name)) 
[01:29:02.639]                             next
[01:29:02.639]                           if (!grepl(pattern, name)) 
[01:29:02.639]                             next
[01:29:02.639]                           invokeRestart(restart)
[01:29:02.639]                           muffled <- TRUE
[01:29:02.639]                           break
[01:29:02.639]                         }
[01:29:02.639]                       }
[01:29:02.639]                     }
[01:29:02.639]                     invisible(muffled)
[01:29:02.639]                   }
[01:29:02.639]                   muffleCondition(cond)
[01:29:02.639]                 })
[01:29:02.639]             }))
[01:29:02.639]             future::FutureResult(value = ...future.value$value, 
[01:29:02.639]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:02.639]                   ...future.rng), globalenv = if (FALSE) 
[01:29:02.639]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:02.639]                     ...future.globalenv.names))
[01:29:02.639]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:02.639]         }, condition = base::local({
[01:29:02.639]             c <- base::c
[01:29:02.639]             inherits <- base::inherits
[01:29:02.639]             invokeRestart <- base::invokeRestart
[01:29:02.639]             length <- base::length
[01:29:02.639]             list <- base::list
[01:29:02.639]             seq.int <- base::seq.int
[01:29:02.639]             signalCondition <- base::signalCondition
[01:29:02.639]             sys.calls <- base::sys.calls
[01:29:02.639]             `[[` <- base::`[[`
[01:29:02.639]             `+` <- base::`+`
[01:29:02.639]             `<<-` <- base::`<<-`
[01:29:02.639]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:02.639]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:02.639]                   3L)]
[01:29:02.639]             }
[01:29:02.639]             function(cond) {
[01:29:02.639]                 is_error <- inherits(cond, "error")
[01:29:02.639]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:02.639]                   NULL)
[01:29:02.639]                 if (is_error) {
[01:29:02.639]                   sessionInformation <- function() {
[01:29:02.639]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:02.639]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:02.639]                       search = base::search(), system = base::Sys.info())
[01:29:02.639]                   }
[01:29:02.639]                   ...future.conditions[[length(...future.conditions) + 
[01:29:02.639]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:02.639]                     cond$call), session = sessionInformation(), 
[01:29:02.639]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:02.639]                   signalCondition(cond)
[01:29:02.639]                 }
[01:29:02.639]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:02.639]                 "immediateCondition"))) {
[01:29:02.639]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:02.639]                   ...future.conditions[[length(...future.conditions) + 
[01:29:02.639]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:02.639]                   if (TRUE && !signal) {
[01:29:02.639]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:02.639]                     {
[01:29:02.639]                       inherits <- base::inherits
[01:29:02.639]                       invokeRestart <- base::invokeRestart
[01:29:02.639]                       is.null <- base::is.null
[01:29:02.639]                       muffled <- FALSE
[01:29:02.639]                       if (inherits(cond, "message")) {
[01:29:02.639]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:02.639]                         if (muffled) 
[01:29:02.639]                           invokeRestart("muffleMessage")
[01:29:02.639]                       }
[01:29:02.639]                       else if (inherits(cond, "warning")) {
[01:29:02.639]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:02.639]                         if (muffled) 
[01:29:02.639]                           invokeRestart("muffleWarning")
[01:29:02.639]                       }
[01:29:02.639]                       else if (inherits(cond, "condition")) {
[01:29:02.639]                         if (!is.null(pattern)) {
[01:29:02.639]                           computeRestarts <- base::computeRestarts
[01:29:02.639]                           grepl <- base::grepl
[01:29:02.639]                           restarts <- computeRestarts(cond)
[01:29:02.639]                           for (restart in restarts) {
[01:29:02.639]                             name <- restart$name
[01:29:02.639]                             if (is.null(name)) 
[01:29:02.639]                               next
[01:29:02.639]                             if (!grepl(pattern, name)) 
[01:29:02.639]                               next
[01:29:02.639]                             invokeRestart(restart)
[01:29:02.639]                             muffled <- TRUE
[01:29:02.639]                             break
[01:29:02.639]                           }
[01:29:02.639]                         }
[01:29:02.639]                       }
[01:29:02.639]                       invisible(muffled)
[01:29:02.639]                     }
[01:29:02.639]                     muffleCondition(cond, pattern = "^muffle")
[01:29:02.639]                   }
[01:29:02.639]                 }
[01:29:02.639]                 else {
[01:29:02.639]                   if (TRUE) {
[01:29:02.639]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:02.639]                     {
[01:29:02.639]                       inherits <- base::inherits
[01:29:02.639]                       invokeRestart <- base::invokeRestart
[01:29:02.639]                       is.null <- base::is.null
[01:29:02.639]                       muffled <- FALSE
[01:29:02.639]                       if (inherits(cond, "message")) {
[01:29:02.639]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:02.639]                         if (muffled) 
[01:29:02.639]                           invokeRestart("muffleMessage")
[01:29:02.639]                       }
[01:29:02.639]                       else if (inherits(cond, "warning")) {
[01:29:02.639]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:02.639]                         if (muffled) 
[01:29:02.639]                           invokeRestart("muffleWarning")
[01:29:02.639]                       }
[01:29:02.639]                       else if (inherits(cond, "condition")) {
[01:29:02.639]                         if (!is.null(pattern)) {
[01:29:02.639]                           computeRestarts <- base::computeRestarts
[01:29:02.639]                           grepl <- base::grepl
[01:29:02.639]                           restarts <- computeRestarts(cond)
[01:29:02.639]                           for (restart in restarts) {
[01:29:02.639]                             name <- restart$name
[01:29:02.639]                             if (is.null(name)) 
[01:29:02.639]                               next
[01:29:02.639]                             if (!grepl(pattern, name)) 
[01:29:02.639]                               next
[01:29:02.639]                             invokeRestart(restart)
[01:29:02.639]                             muffled <- TRUE
[01:29:02.639]                             break
[01:29:02.639]                           }
[01:29:02.639]                         }
[01:29:02.639]                       }
[01:29:02.639]                       invisible(muffled)
[01:29:02.639]                     }
[01:29:02.639]                     muffleCondition(cond, pattern = "^muffle")
[01:29:02.639]                   }
[01:29:02.639]                 }
[01:29:02.639]             }
[01:29:02.639]         }))
[01:29:02.639]     }, error = function(ex) {
[01:29:02.639]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:02.639]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:02.639]                 ...future.rng), started = ...future.startTime, 
[01:29:02.639]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:02.639]             version = "1.8"), class = "FutureResult")
[01:29:02.639]     }, finally = {
[01:29:02.639]         if (!identical(...future.workdir, getwd())) 
[01:29:02.639]             setwd(...future.workdir)
[01:29:02.639]         {
[01:29:02.639]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:02.639]                 ...future.oldOptions$nwarnings <- NULL
[01:29:02.639]             }
[01:29:02.639]             base::options(...future.oldOptions)
[01:29:02.639]             if (.Platform$OS.type == "windows") {
[01:29:02.639]                 old_names <- names(...future.oldEnvVars)
[01:29:02.639]                 envs <- base::Sys.getenv()
[01:29:02.639]                 names <- names(envs)
[01:29:02.639]                 common <- intersect(names, old_names)
[01:29:02.639]                 added <- setdiff(names, old_names)
[01:29:02.639]                 removed <- setdiff(old_names, names)
[01:29:02.639]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:02.639]                   envs[common]]
[01:29:02.639]                 NAMES <- toupper(changed)
[01:29:02.639]                 args <- list()
[01:29:02.639]                 for (kk in seq_along(NAMES)) {
[01:29:02.639]                   name <- changed[[kk]]
[01:29:02.639]                   NAME <- NAMES[[kk]]
[01:29:02.639]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:02.639]                     next
[01:29:02.639]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:02.639]                 }
[01:29:02.639]                 NAMES <- toupper(added)
[01:29:02.639]                 for (kk in seq_along(NAMES)) {
[01:29:02.639]                   name <- added[[kk]]
[01:29:02.639]                   NAME <- NAMES[[kk]]
[01:29:02.639]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:02.639]                     next
[01:29:02.639]                   args[[name]] <- ""
[01:29:02.639]                 }
[01:29:02.639]                 NAMES <- toupper(removed)
[01:29:02.639]                 for (kk in seq_along(NAMES)) {
[01:29:02.639]                   name <- removed[[kk]]
[01:29:02.639]                   NAME <- NAMES[[kk]]
[01:29:02.639]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:02.639]                     next
[01:29:02.639]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:02.639]                 }
[01:29:02.639]                 if (length(args) > 0) 
[01:29:02.639]                   base::do.call(base::Sys.setenv, args = args)
[01:29:02.639]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:02.639]             }
[01:29:02.639]             else {
[01:29:02.639]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:02.639]             }
[01:29:02.639]             {
[01:29:02.639]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:02.639]                   0L) {
[01:29:02.639]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:02.639]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:02.639]                   base::options(opts)
[01:29:02.639]                 }
[01:29:02.639]                 {
[01:29:02.639]                   {
[01:29:02.639]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:02.639]                     NULL
[01:29:02.639]                   }
[01:29:02.639]                   options(future.plan = NULL)
[01:29:02.639]                   if (is.na(NA_character_)) 
[01:29:02.639]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:02.639]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:02.639]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:02.639]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:02.639]                     envir = parent.frame()) 
[01:29:02.639]                   {
[01:29:02.639]                     if (is.function(workers)) 
[01:29:02.639]                       workers <- workers()
[01:29:02.639]                     workers <- structure(as.integer(workers), 
[01:29:02.639]                       class = class(workers))
[01:29:02.639]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:02.639]                       workers >= 1)
[01:29:02.639]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:02.639]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:02.639]                     }
[01:29:02.639]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:02.639]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:02.639]                       envir = envir)
[01:29:02.639]                     if (!future$lazy) 
[01:29:02.639]                       future <- run(future)
[01:29:02.639]                     invisible(future)
[01:29:02.639]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:02.639]                 }
[01:29:02.639]             }
[01:29:02.639]         }
[01:29:02.639]     })
[01:29:02.639]     if (TRUE) {
[01:29:02.639]         base::sink(type = "output", split = FALSE)
[01:29:02.639]         if (TRUE) {
[01:29:02.639]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:02.639]         }
[01:29:02.639]         else {
[01:29:02.639]             ...future.result["stdout"] <- base::list(NULL)
[01:29:02.639]         }
[01:29:02.639]         base::close(...future.stdout)
[01:29:02.639]         ...future.stdout <- NULL
[01:29:02.639]     }
[01:29:02.639]     ...future.result$conditions <- ...future.conditions
[01:29:02.639]     ...future.result$finished <- base::Sys.time()
[01:29:02.639]     ...future.result
[01:29:02.639] }
[01:29:02.645] MultisessionFuture started
[01:29:02.645] - Launch lazy future ... done
[01:29:02.645] run() for 'MultisessionFuture' ... done
[01:29:02.663] receiveMessageFromWorker() for ClusterFuture ...
[01:29:02.663] - Validating connection of MultisessionFuture
[01:29:02.663] - received message: FutureResult
[01:29:02.664] - Received FutureResult
[01:29:02.664] - Erased future from FutureRegistry
[01:29:02.664] result() for ClusterFuture ...
[01:29:02.664] - result already collected: FutureResult
[01:29:02.664] result() for ClusterFuture ... done
[01:29:02.664] signalConditions() ...
[01:29:02.665]  - include = 'immediateCondition'
[01:29:02.665]  - exclude = 
[01:29:02.665]  - resignal = FALSE
[01:29:02.665]  - Number of conditions: 1
[01:29:02.665] signalConditions() ... done
[01:29:02.665] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:02.666] A MultisessionFuture was resolved (result was not collected)
- result = FALSE, recursive = 2 ... DONE
- result = FALSE, recursive = Inf ...
[01:29:02.666] getGlobalsAndPackages() ...
[01:29:02.666] Searching for globals...
[01:29:02.668] - globals found: [3] '{', 'Sys.sleep', 'list'
[01:29:02.668] Searching for globals ... DONE
[01:29:02.668] Resolving globals: FALSE
[01:29:02.668] 
[01:29:02.669] 
[01:29:02.669] getGlobalsAndPackages() ... DONE
[01:29:02.669] run() for 'Future' ...
[01:29:02.669] - state: 'created'
[01:29:02.669] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:02.686] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:02.686] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:02.687]   - Field: 'node'
[01:29:02.687]   - Field: 'label'
[01:29:02.687]   - Field: 'local'
[01:29:02.687]   - Field: 'owner'
[01:29:02.687]   - Field: 'envir'
[01:29:02.687]   - Field: 'workers'
[01:29:02.688]   - Field: 'packages'
[01:29:02.688]   - Field: 'gc'
[01:29:02.688]   - Field: 'conditions'
[01:29:02.688]   - Field: 'persistent'
[01:29:02.688]   - Field: 'expr'
[01:29:02.689]   - Field: 'uuid'
[01:29:02.689]   - Field: 'seed'
[01:29:02.689]   - Field: 'version'
[01:29:02.689]   - Field: 'result'
[01:29:02.689]   - Field: 'asynchronous'
[01:29:02.689]   - Field: 'calls'
[01:29:02.690]   - Field: 'globals'
[01:29:02.690]   - Field: 'stdout'
[01:29:02.690]   - Field: 'earlySignal'
[01:29:02.690]   - Field: 'lazy'
[01:29:02.690]   - Field: 'state'
[01:29:02.690] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:02.691] - Launch lazy future ...
[01:29:02.691] Packages needed by the future expression (n = 0): <none>
[01:29:02.691] Packages needed by future strategies (n = 0): <none>
[01:29:02.692] {
[01:29:02.692]     {
[01:29:02.692]         {
[01:29:02.692]             ...future.startTime <- base::Sys.time()
[01:29:02.692]             {
[01:29:02.692]                 {
[01:29:02.692]                   {
[01:29:02.692]                     {
[01:29:02.692]                       base::local({
[01:29:02.692]                         has_future <- base::requireNamespace("future", 
[01:29:02.692]                           quietly = TRUE)
[01:29:02.692]                         if (has_future) {
[01:29:02.692]                           ns <- base::getNamespace("future")
[01:29:02.692]                           version <- ns[[".package"]][["version"]]
[01:29:02.692]                           if (is.null(version)) 
[01:29:02.692]                             version <- utils::packageVersion("future")
[01:29:02.692]                         }
[01:29:02.692]                         else {
[01:29:02.692]                           version <- NULL
[01:29:02.692]                         }
[01:29:02.692]                         if (!has_future || version < "1.8.0") {
[01:29:02.692]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:02.692]                             "", base::R.version$version.string), 
[01:29:02.692]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:02.692]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:02.692]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:02.692]                               "release", "version")], collapse = " "), 
[01:29:02.692]                             hostname = base::Sys.info()[["nodename"]])
[01:29:02.692]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:02.692]                             info)
[01:29:02.692]                           info <- base::paste(info, collapse = "; ")
[01:29:02.692]                           if (!has_future) {
[01:29:02.692]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:02.692]                               info)
[01:29:02.692]                           }
[01:29:02.692]                           else {
[01:29:02.692]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:02.692]                               info, version)
[01:29:02.692]                           }
[01:29:02.692]                           base::stop(msg)
[01:29:02.692]                         }
[01:29:02.692]                       })
[01:29:02.692]                     }
[01:29:02.692]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:02.692]                     base::options(mc.cores = 1L)
[01:29:02.692]                   }
[01:29:02.692]                   options(future.plan = NULL)
[01:29:02.692]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:02.692]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:02.692]                 }
[01:29:02.692]                 ...future.workdir <- getwd()
[01:29:02.692]             }
[01:29:02.692]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:02.692]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:02.692]         }
[01:29:02.692]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:02.692]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:02.692]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:02.692]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:02.692]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:02.692]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:02.692]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:02.692]             base::names(...future.oldOptions))
[01:29:02.692]     }
[01:29:02.692]     if (FALSE) {
[01:29:02.692]     }
[01:29:02.692]     else {
[01:29:02.692]         if (TRUE) {
[01:29:02.692]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:02.692]                 open = "w")
[01:29:02.692]         }
[01:29:02.692]         else {
[01:29:02.692]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:02.692]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:02.692]         }
[01:29:02.692]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:02.692]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:02.692]             base::sink(type = "output", split = FALSE)
[01:29:02.692]             base::close(...future.stdout)
[01:29:02.692]         }, add = TRUE)
[01:29:02.692]     }
[01:29:02.692]     ...future.frame <- base::sys.nframe()
[01:29:02.692]     ...future.conditions <- base::list()
[01:29:02.692]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:02.692]     if (FALSE) {
[01:29:02.692]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:02.692]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:02.692]     }
[01:29:02.692]     ...future.result <- base::tryCatch({
[01:29:02.692]         base::withCallingHandlers({
[01:29:02.692]             ...future.value <- base::withVisible(base::local({
[01:29:02.692]                 ...future.makeSendCondition <- base::local({
[01:29:02.692]                   sendCondition <- NULL
[01:29:02.692]                   function(frame = 1L) {
[01:29:02.692]                     if (is.function(sendCondition)) 
[01:29:02.692]                       return(sendCondition)
[01:29:02.692]                     ns <- getNamespace("parallel")
[01:29:02.692]                     if (exists("sendData", mode = "function", 
[01:29:02.692]                       envir = ns)) {
[01:29:02.692]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:02.692]                         envir = ns)
[01:29:02.692]                       envir <- sys.frame(frame)
[01:29:02.692]                       master <- NULL
[01:29:02.692]                       while (!identical(envir, .GlobalEnv) && 
[01:29:02.692]                         !identical(envir, emptyenv())) {
[01:29:02.692]                         if (exists("master", mode = "list", envir = envir, 
[01:29:02.692]                           inherits = FALSE)) {
[01:29:02.692]                           master <- get("master", mode = "list", 
[01:29:02.692]                             envir = envir, inherits = FALSE)
[01:29:02.692]                           if (inherits(master, c("SOCKnode", 
[01:29:02.692]                             "SOCK0node"))) {
[01:29:02.692]                             sendCondition <<- function(cond) {
[01:29:02.692]                               data <- list(type = "VALUE", value = cond, 
[01:29:02.692]                                 success = TRUE)
[01:29:02.692]                               parallel_sendData(master, data)
[01:29:02.692]                             }
[01:29:02.692]                             return(sendCondition)
[01:29:02.692]                           }
[01:29:02.692]                         }
[01:29:02.692]                         frame <- frame + 1L
[01:29:02.692]                         envir <- sys.frame(frame)
[01:29:02.692]                       }
[01:29:02.692]                     }
[01:29:02.692]                     sendCondition <<- function(cond) NULL
[01:29:02.692]                   }
[01:29:02.692]                 })
[01:29:02.692]                 withCallingHandlers({
[01:29:02.692]                   {
[01:29:02.692]                     Sys.sleep(0.5)
[01:29:02.692]                     list(a = 1, b = 42L)
[01:29:02.692]                   }
[01:29:02.692]                 }, immediateCondition = function(cond) {
[01:29:02.692]                   sendCondition <- ...future.makeSendCondition()
[01:29:02.692]                   sendCondition(cond)
[01:29:02.692]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:02.692]                   {
[01:29:02.692]                     inherits <- base::inherits
[01:29:02.692]                     invokeRestart <- base::invokeRestart
[01:29:02.692]                     is.null <- base::is.null
[01:29:02.692]                     muffled <- FALSE
[01:29:02.692]                     if (inherits(cond, "message")) {
[01:29:02.692]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:02.692]                       if (muffled) 
[01:29:02.692]                         invokeRestart("muffleMessage")
[01:29:02.692]                     }
[01:29:02.692]                     else if (inherits(cond, "warning")) {
[01:29:02.692]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:02.692]                       if (muffled) 
[01:29:02.692]                         invokeRestart("muffleWarning")
[01:29:02.692]                     }
[01:29:02.692]                     else if (inherits(cond, "condition")) {
[01:29:02.692]                       if (!is.null(pattern)) {
[01:29:02.692]                         computeRestarts <- base::computeRestarts
[01:29:02.692]                         grepl <- base::grepl
[01:29:02.692]                         restarts <- computeRestarts(cond)
[01:29:02.692]                         for (restart in restarts) {
[01:29:02.692]                           name <- restart$name
[01:29:02.692]                           if (is.null(name)) 
[01:29:02.692]                             next
[01:29:02.692]                           if (!grepl(pattern, name)) 
[01:29:02.692]                             next
[01:29:02.692]                           invokeRestart(restart)
[01:29:02.692]                           muffled <- TRUE
[01:29:02.692]                           break
[01:29:02.692]                         }
[01:29:02.692]                       }
[01:29:02.692]                     }
[01:29:02.692]                     invisible(muffled)
[01:29:02.692]                   }
[01:29:02.692]                   muffleCondition(cond)
[01:29:02.692]                 })
[01:29:02.692]             }))
[01:29:02.692]             future::FutureResult(value = ...future.value$value, 
[01:29:02.692]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:02.692]                   ...future.rng), globalenv = if (FALSE) 
[01:29:02.692]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:02.692]                     ...future.globalenv.names))
[01:29:02.692]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:02.692]         }, condition = base::local({
[01:29:02.692]             c <- base::c
[01:29:02.692]             inherits <- base::inherits
[01:29:02.692]             invokeRestart <- base::invokeRestart
[01:29:02.692]             length <- base::length
[01:29:02.692]             list <- base::list
[01:29:02.692]             seq.int <- base::seq.int
[01:29:02.692]             signalCondition <- base::signalCondition
[01:29:02.692]             sys.calls <- base::sys.calls
[01:29:02.692]             `[[` <- base::`[[`
[01:29:02.692]             `+` <- base::`+`
[01:29:02.692]             `<<-` <- base::`<<-`
[01:29:02.692]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:02.692]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:02.692]                   3L)]
[01:29:02.692]             }
[01:29:02.692]             function(cond) {
[01:29:02.692]                 is_error <- inherits(cond, "error")
[01:29:02.692]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:02.692]                   NULL)
[01:29:02.692]                 if (is_error) {
[01:29:02.692]                   sessionInformation <- function() {
[01:29:02.692]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:02.692]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:02.692]                       search = base::search(), system = base::Sys.info())
[01:29:02.692]                   }
[01:29:02.692]                   ...future.conditions[[length(...future.conditions) + 
[01:29:02.692]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:02.692]                     cond$call), session = sessionInformation(), 
[01:29:02.692]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:02.692]                   signalCondition(cond)
[01:29:02.692]                 }
[01:29:02.692]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:02.692]                 "immediateCondition"))) {
[01:29:02.692]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:02.692]                   ...future.conditions[[length(...future.conditions) + 
[01:29:02.692]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:02.692]                   if (TRUE && !signal) {
[01:29:02.692]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:02.692]                     {
[01:29:02.692]                       inherits <- base::inherits
[01:29:02.692]                       invokeRestart <- base::invokeRestart
[01:29:02.692]                       is.null <- base::is.null
[01:29:02.692]                       muffled <- FALSE
[01:29:02.692]                       if (inherits(cond, "message")) {
[01:29:02.692]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:02.692]                         if (muffled) 
[01:29:02.692]                           invokeRestart("muffleMessage")
[01:29:02.692]                       }
[01:29:02.692]                       else if (inherits(cond, "warning")) {
[01:29:02.692]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:02.692]                         if (muffled) 
[01:29:02.692]                           invokeRestart("muffleWarning")
[01:29:02.692]                       }
[01:29:02.692]                       else if (inherits(cond, "condition")) {
[01:29:02.692]                         if (!is.null(pattern)) {
[01:29:02.692]                           computeRestarts <- base::computeRestarts
[01:29:02.692]                           grepl <- base::grepl
[01:29:02.692]                           restarts <- computeRestarts(cond)
[01:29:02.692]                           for (restart in restarts) {
[01:29:02.692]                             name <- restart$name
[01:29:02.692]                             if (is.null(name)) 
[01:29:02.692]                               next
[01:29:02.692]                             if (!grepl(pattern, name)) 
[01:29:02.692]                               next
[01:29:02.692]                             invokeRestart(restart)
[01:29:02.692]                             muffled <- TRUE
[01:29:02.692]                             break
[01:29:02.692]                           }
[01:29:02.692]                         }
[01:29:02.692]                       }
[01:29:02.692]                       invisible(muffled)
[01:29:02.692]                     }
[01:29:02.692]                     muffleCondition(cond, pattern = "^muffle")
[01:29:02.692]                   }
[01:29:02.692]                 }
[01:29:02.692]                 else {
[01:29:02.692]                   if (TRUE) {
[01:29:02.692]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:02.692]                     {
[01:29:02.692]                       inherits <- base::inherits
[01:29:02.692]                       invokeRestart <- base::invokeRestart
[01:29:02.692]                       is.null <- base::is.null
[01:29:02.692]                       muffled <- FALSE
[01:29:02.692]                       if (inherits(cond, "message")) {
[01:29:02.692]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:02.692]                         if (muffled) 
[01:29:02.692]                           invokeRestart("muffleMessage")
[01:29:02.692]                       }
[01:29:02.692]                       else if (inherits(cond, "warning")) {
[01:29:02.692]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:02.692]                         if (muffled) 
[01:29:02.692]                           invokeRestart("muffleWarning")
[01:29:02.692]                       }
[01:29:02.692]                       else if (inherits(cond, "condition")) {
[01:29:02.692]                         if (!is.null(pattern)) {
[01:29:02.692]                           computeRestarts <- base::computeRestarts
[01:29:02.692]                           grepl <- base::grepl
[01:29:02.692]                           restarts <- computeRestarts(cond)
[01:29:02.692]                           for (restart in restarts) {
[01:29:02.692]                             name <- restart$name
[01:29:02.692]                             if (is.null(name)) 
[01:29:02.692]                               next
[01:29:02.692]                             if (!grepl(pattern, name)) 
[01:29:02.692]                               next
[01:29:02.692]                             invokeRestart(restart)
[01:29:02.692]                             muffled <- TRUE
[01:29:02.692]                             break
[01:29:02.692]                           }
[01:29:02.692]                         }
[01:29:02.692]                       }
[01:29:02.692]                       invisible(muffled)
[01:29:02.692]                     }
[01:29:02.692]                     muffleCondition(cond, pattern = "^muffle")
[01:29:02.692]                   }
[01:29:02.692]                 }
[01:29:02.692]             }
[01:29:02.692]         }))
[01:29:02.692]     }, error = function(ex) {
[01:29:02.692]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:02.692]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:02.692]                 ...future.rng), started = ...future.startTime, 
[01:29:02.692]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:02.692]             version = "1.8"), class = "FutureResult")
[01:29:02.692]     }, finally = {
[01:29:02.692]         if (!identical(...future.workdir, getwd())) 
[01:29:02.692]             setwd(...future.workdir)
[01:29:02.692]         {
[01:29:02.692]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:02.692]                 ...future.oldOptions$nwarnings <- NULL
[01:29:02.692]             }
[01:29:02.692]             base::options(...future.oldOptions)
[01:29:02.692]             if (.Platform$OS.type == "windows") {
[01:29:02.692]                 old_names <- names(...future.oldEnvVars)
[01:29:02.692]                 envs <- base::Sys.getenv()
[01:29:02.692]                 names <- names(envs)
[01:29:02.692]                 common <- intersect(names, old_names)
[01:29:02.692]                 added <- setdiff(names, old_names)
[01:29:02.692]                 removed <- setdiff(old_names, names)
[01:29:02.692]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:02.692]                   envs[common]]
[01:29:02.692]                 NAMES <- toupper(changed)
[01:29:02.692]                 args <- list()
[01:29:02.692]                 for (kk in seq_along(NAMES)) {
[01:29:02.692]                   name <- changed[[kk]]
[01:29:02.692]                   NAME <- NAMES[[kk]]
[01:29:02.692]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:02.692]                     next
[01:29:02.692]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:02.692]                 }
[01:29:02.692]                 NAMES <- toupper(added)
[01:29:02.692]                 for (kk in seq_along(NAMES)) {
[01:29:02.692]                   name <- added[[kk]]
[01:29:02.692]                   NAME <- NAMES[[kk]]
[01:29:02.692]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:02.692]                     next
[01:29:02.692]                   args[[name]] <- ""
[01:29:02.692]                 }
[01:29:02.692]                 NAMES <- toupper(removed)
[01:29:02.692]                 for (kk in seq_along(NAMES)) {
[01:29:02.692]                   name <- removed[[kk]]
[01:29:02.692]                   NAME <- NAMES[[kk]]
[01:29:02.692]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:02.692]                     next
[01:29:02.692]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:02.692]                 }
[01:29:02.692]                 if (length(args) > 0) 
[01:29:02.692]                   base::do.call(base::Sys.setenv, args = args)
[01:29:02.692]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:02.692]             }
[01:29:02.692]             else {
[01:29:02.692]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:02.692]             }
[01:29:02.692]             {
[01:29:02.692]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:02.692]                   0L) {
[01:29:02.692]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:02.692]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:02.692]                   base::options(opts)
[01:29:02.692]                 }
[01:29:02.692]                 {
[01:29:02.692]                   {
[01:29:02.692]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:02.692]                     NULL
[01:29:02.692]                   }
[01:29:02.692]                   options(future.plan = NULL)
[01:29:02.692]                   if (is.na(NA_character_)) 
[01:29:02.692]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:02.692]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:02.692]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:02.692]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:02.692]                     envir = parent.frame()) 
[01:29:02.692]                   {
[01:29:02.692]                     if (is.function(workers)) 
[01:29:02.692]                       workers <- workers()
[01:29:02.692]                     workers <- structure(as.integer(workers), 
[01:29:02.692]                       class = class(workers))
[01:29:02.692]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:02.692]                       workers >= 1)
[01:29:02.692]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:02.692]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:02.692]                     }
[01:29:02.692]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:02.692]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:02.692]                       envir = envir)
[01:29:02.692]                     if (!future$lazy) 
[01:29:02.692]                       future <- run(future)
[01:29:02.692]                     invisible(future)
[01:29:02.692]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:02.692]                 }
[01:29:02.692]             }
[01:29:02.692]         }
[01:29:02.692]     })
[01:29:02.692]     if (TRUE) {
[01:29:02.692]         base::sink(type = "output", split = FALSE)
[01:29:02.692]         if (TRUE) {
[01:29:02.692]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:02.692]         }
[01:29:02.692]         else {
[01:29:02.692]             ...future.result["stdout"] <- base::list(NULL)
[01:29:02.692]         }
[01:29:02.692]         base::close(...future.stdout)
[01:29:02.692]         ...future.stdout <- NULL
[01:29:02.692]     }
[01:29:02.692]     ...future.result$conditions <- ...future.conditions
[01:29:02.692]     ...future.result$finished <- base::Sys.time()
[01:29:02.692]     ...future.result
[01:29:02.692] }
[01:29:02.697] MultisessionFuture started
[01:29:02.697] - Launch lazy future ... done
[01:29:02.698] run() for 'MultisessionFuture' ... done
[01:29:03.221] receiveMessageFromWorker() for ClusterFuture ...
[01:29:03.221] - Validating connection of MultisessionFuture
[01:29:03.222] - received message: FutureResult
[01:29:03.222] - Received FutureResult
[01:29:03.222] - Erased future from FutureRegistry
[01:29:03.222] result() for ClusterFuture ...
[01:29:03.222] - result already collected: FutureResult
[01:29:03.222] result() for ClusterFuture ... done
[01:29:03.223] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:03.223] A MultisessionFuture was resolved (result was not collected)
[01:29:03.223] getGlobalsAndPackages() ...
[01:29:03.223] Searching for globals...
[01:29:03.225] - globals found: [3] '{', 'Sys.sleep', 'list'
[01:29:03.225] Searching for globals ... DONE
[01:29:03.225] Resolving globals: FALSE
[01:29:03.226] 
[01:29:03.226] 
[01:29:03.226] getGlobalsAndPackages() ... DONE
[01:29:03.226] run() for 'Future' ...
[01:29:03.227] - state: 'created'
[01:29:03.227] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:03.241] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:03.241] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:03.242]   - Field: 'node'
[01:29:03.242]   - Field: 'label'
[01:29:03.242]   - Field: 'local'
[01:29:03.242]   - Field: 'owner'
[01:29:03.242]   - Field: 'envir'
[01:29:03.243]   - Field: 'workers'
[01:29:03.243]   - Field: 'packages'
[01:29:03.243]   - Field: 'gc'
[01:29:03.243]   - Field: 'conditions'
[01:29:03.243]   - Field: 'persistent'
[01:29:03.243]   - Field: 'expr'
[01:29:03.244]   - Field: 'uuid'
[01:29:03.244]   - Field: 'seed'
[01:29:03.244]   - Field: 'version'
[01:29:03.244]   - Field: 'result'
[01:29:03.244]   - Field: 'asynchronous'
[01:29:03.244]   - Field: 'calls'
[01:29:03.245]   - Field: 'globals'
[01:29:03.245]   - Field: 'stdout'
[01:29:03.245]   - Field: 'earlySignal'
[01:29:03.245]   - Field: 'lazy'
[01:29:03.245]   - Field: 'state'
[01:29:03.245] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:03.246] - Launch lazy future ...
[01:29:03.246] Packages needed by the future expression (n = 0): <none>
[01:29:03.246] Packages needed by future strategies (n = 0): <none>
[01:29:03.247] {
[01:29:03.247]     {
[01:29:03.247]         {
[01:29:03.247]             ...future.startTime <- base::Sys.time()
[01:29:03.247]             {
[01:29:03.247]                 {
[01:29:03.247]                   {
[01:29:03.247]                     {
[01:29:03.247]                       base::local({
[01:29:03.247]                         has_future <- base::requireNamespace("future", 
[01:29:03.247]                           quietly = TRUE)
[01:29:03.247]                         if (has_future) {
[01:29:03.247]                           ns <- base::getNamespace("future")
[01:29:03.247]                           version <- ns[[".package"]][["version"]]
[01:29:03.247]                           if (is.null(version)) 
[01:29:03.247]                             version <- utils::packageVersion("future")
[01:29:03.247]                         }
[01:29:03.247]                         else {
[01:29:03.247]                           version <- NULL
[01:29:03.247]                         }
[01:29:03.247]                         if (!has_future || version < "1.8.0") {
[01:29:03.247]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:03.247]                             "", base::R.version$version.string), 
[01:29:03.247]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:03.247]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:03.247]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:03.247]                               "release", "version")], collapse = " "), 
[01:29:03.247]                             hostname = base::Sys.info()[["nodename"]])
[01:29:03.247]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:03.247]                             info)
[01:29:03.247]                           info <- base::paste(info, collapse = "; ")
[01:29:03.247]                           if (!has_future) {
[01:29:03.247]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:03.247]                               info)
[01:29:03.247]                           }
[01:29:03.247]                           else {
[01:29:03.247]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:03.247]                               info, version)
[01:29:03.247]                           }
[01:29:03.247]                           base::stop(msg)
[01:29:03.247]                         }
[01:29:03.247]                       })
[01:29:03.247]                     }
[01:29:03.247]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:03.247]                     base::options(mc.cores = 1L)
[01:29:03.247]                   }
[01:29:03.247]                   options(future.plan = NULL)
[01:29:03.247]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:03.247]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:03.247]                 }
[01:29:03.247]                 ...future.workdir <- getwd()
[01:29:03.247]             }
[01:29:03.247]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:03.247]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:03.247]         }
[01:29:03.247]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:03.247]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:03.247]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:03.247]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:03.247]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:03.247]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:03.247]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:03.247]             base::names(...future.oldOptions))
[01:29:03.247]     }
[01:29:03.247]     if (FALSE) {
[01:29:03.247]     }
[01:29:03.247]     else {
[01:29:03.247]         if (TRUE) {
[01:29:03.247]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:03.247]                 open = "w")
[01:29:03.247]         }
[01:29:03.247]         else {
[01:29:03.247]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:03.247]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:03.247]         }
[01:29:03.247]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:03.247]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:03.247]             base::sink(type = "output", split = FALSE)
[01:29:03.247]             base::close(...future.stdout)
[01:29:03.247]         }, add = TRUE)
[01:29:03.247]     }
[01:29:03.247]     ...future.frame <- base::sys.nframe()
[01:29:03.247]     ...future.conditions <- base::list()
[01:29:03.247]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:03.247]     if (FALSE) {
[01:29:03.247]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:03.247]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:03.247]     }
[01:29:03.247]     ...future.result <- base::tryCatch({
[01:29:03.247]         base::withCallingHandlers({
[01:29:03.247]             ...future.value <- base::withVisible(base::local({
[01:29:03.247]                 ...future.makeSendCondition <- base::local({
[01:29:03.247]                   sendCondition <- NULL
[01:29:03.247]                   function(frame = 1L) {
[01:29:03.247]                     if (is.function(sendCondition)) 
[01:29:03.247]                       return(sendCondition)
[01:29:03.247]                     ns <- getNamespace("parallel")
[01:29:03.247]                     if (exists("sendData", mode = "function", 
[01:29:03.247]                       envir = ns)) {
[01:29:03.247]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:03.247]                         envir = ns)
[01:29:03.247]                       envir <- sys.frame(frame)
[01:29:03.247]                       master <- NULL
[01:29:03.247]                       while (!identical(envir, .GlobalEnv) && 
[01:29:03.247]                         !identical(envir, emptyenv())) {
[01:29:03.247]                         if (exists("master", mode = "list", envir = envir, 
[01:29:03.247]                           inherits = FALSE)) {
[01:29:03.247]                           master <- get("master", mode = "list", 
[01:29:03.247]                             envir = envir, inherits = FALSE)
[01:29:03.247]                           if (inherits(master, c("SOCKnode", 
[01:29:03.247]                             "SOCK0node"))) {
[01:29:03.247]                             sendCondition <<- function(cond) {
[01:29:03.247]                               data <- list(type = "VALUE", value = cond, 
[01:29:03.247]                                 success = TRUE)
[01:29:03.247]                               parallel_sendData(master, data)
[01:29:03.247]                             }
[01:29:03.247]                             return(sendCondition)
[01:29:03.247]                           }
[01:29:03.247]                         }
[01:29:03.247]                         frame <- frame + 1L
[01:29:03.247]                         envir <- sys.frame(frame)
[01:29:03.247]                       }
[01:29:03.247]                     }
[01:29:03.247]                     sendCondition <<- function(cond) NULL
[01:29:03.247]                   }
[01:29:03.247]                 })
[01:29:03.247]                 withCallingHandlers({
[01:29:03.247]                   {
[01:29:03.247]                     Sys.sleep(0.5)
[01:29:03.247]                     list(a = 1, b = 42L)
[01:29:03.247]                   }
[01:29:03.247]                 }, immediateCondition = function(cond) {
[01:29:03.247]                   sendCondition <- ...future.makeSendCondition()
[01:29:03.247]                   sendCondition(cond)
[01:29:03.247]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:03.247]                   {
[01:29:03.247]                     inherits <- base::inherits
[01:29:03.247]                     invokeRestart <- base::invokeRestart
[01:29:03.247]                     is.null <- base::is.null
[01:29:03.247]                     muffled <- FALSE
[01:29:03.247]                     if (inherits(cond, "message")) {
[01:29:03.247]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:03.247]                       if (muffled) 
[01:29:03.247]                         invokeRestart("muffleMessage")
[01:29:03.247]                     }
[01:29:03.247]                     else if (inherits(cond, "warning")) {
[01:29:03.247]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:03.247]                       if (muffled) 
[01:29:03.247]                         invokeRestart("muffleWarning")
[01:29:03.247]                     }
[01:29:03.247]                     else if (inherits(cond, "condition")) {
[01:29:03.247]                       if (!is.null(pattern)) {
[01:29:03.247]                         computeRestarts <- base::computeRestarts
[01:29:03.247]                         grepl <- base::grepl
[01:29:03.247]                         restarts <- computeRestarts(cond)
[01:29:03.247]                         for (restart in restarts) {
[01:29:03.247]                           name <- restart$name
[01:29:03.247]                           if (is.null(name)) 
[01:29:03.247]                             next
[01:29:03.247]                           if (!grepl(pattern, name)) 
[01:29:03.247]                             next
[01:29:03.247]                           invokeRestart(restart)
[01:29:03.247]                           muffled <- TRUE
[01:29:03.247]                           break
[01:29:03.247]                         }
[01:29:03.247]                       }
[01:29:03.247]                     }
[01:29:03.247]                     invisible(muffled)
[01:29:03.247]                   }
[01:29:03.247]                   muffleCondition(cond)
[01:29:03.247]                 })
[01:29:03.247]             }))
[01:29:03.247]             future::FutureResult(value = ...future.value$value, 
[01:29:03.247]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:03.247]                   ...future.rng), globalenv = if (FALSE) 
[01:29:03.247]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:03.247]                     ...future.globalenv.names))
[01:29:03.247]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:03.247]         }, condition = base::local({
[01:29:03.247]             c <- base::c
[01:29:03.247]             inherits <- base::inherits
[01:29:03.247]             invokeRestart <- base::invokeRestart
[01:29:03.247]             length <- base::length
[01:29:03.247]             list <- base::list
[01:29:03.247]             seq.int <- base::seq.int
[01:29:03.247]             signalCondition <- base::signalCondition
[01:29:03.247]             sys.calls <- base::sys.calls
[01:29:03.247]             `[[` <- base::`[[`
[01:29:03.247]             `+` <- base::`+`
[01:29:03.247]             `<<-` <- base::`<<-`
[01:29:03.247]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:03.247]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:03.247]                   3L)]
[01:29:03.247]             }
[01:29:03.247]             function(cond) {
[01:29:03.247]                 is_error <- inherits(cond, "error")
[01:29:03.247]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:03.247]                   NULL)
[01:29:03.247]                 if (is_error) {
[01:29:03.247]                   sessionInformation <- function() {
[01:29:03.247]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:03.247]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:03.247]                       search = base::search(), system = base::Sys.info())
[01:29:03.247]                   }
[01:29:03.247]                   ...future.conditions[[length(...future.conditions) + 
[01:29:03.247]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:03.247]                     cond$call), session = sessionInformation(), 
[01:29:03.247]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:03.247]                   signalCondition(cond)
[01:29:03.247]                 }
[01:29:03.247]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:03.247]                 "immediateCondition"))) {
[01:29:03.247]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:03.247]                   ...future.conditions[[length(...future.conditions) + 
[01:29:03.247]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:03.247]                   if (TRUE && !signal) {
[01:29:03.247]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:03.247]                     {
[01:29:03.247]                       inherits <- base::inherits
[01:29:03.247]                       invokeRestart <- base::invokeRestart
[01:29:03.247]                       is.null <- base::is.null
[01:29:03.247]                       muffled <- FALSE
[01:29:03.247]                       if (inherits(cond, "message")) {
[01:29:03.247]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:03.247]                         if (muffled) 
[01:29:03.247]                           invokeRestart("muffleMessage")
[01:29:03.247]                       }
[01:29:03.247]                       else if (inherits(cond, "warning")) {
[01:29:03.247]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:03.247]                         if (muffled) 
[01:29:03.247]                           invokeRestart("muffleWarning")
[01:29:03.247]                       }
[01:29:03.247]                       else if (inherits(cond, "condition")) {
[01:29:03.247]                         if (!is.null(pattern)) {
[01:29:03.247]                           computeRestarts <- base::computeRestarts
[01:29:03.247]                           grepl <- base::grepl
[01:29:03.247]                           restarts <- computeRestarts(cond)
[01:29:03.247]                           for (restart in restarts) {
[01:29:03.247]                             name <- restart$name
[01:29:03.247]                             if (is.null(name)) 
[01:29:03.247]                               next
[01:29:03.247]                             if (!grepl(pattern, name)) 
[01:29:03.247]                               next
[01:29:03.247]                             invokeRestart(restart)
[01:29:03.247]                             muffled <- TRUE
[01:29:03.247]                             break
[01:29:03.247]                           }
[01:29:03.247]                         }
[01:29:03.247]                       }
[01:29:03.247]                       invisible(muffled)
[01:29:03.247]                     }
[01:29:03.247]                     muffleCondition(cond, pattern = "^muffle")
[01:29:03.247]                   }
[01:29:03.247]                 }
[01:29:03.247]                 else {
[01:29:03.247]                   if (TRUE) {
[01:29:03.247]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:03.247]                     {
[01:29:03.247]                       inherits <- base::inherits
[01:29:03.247]                       invokeRestart <- base::invokeRestart
[01:29:03.247]                       is.null <- base::is.null
[01:29:03.247]                       muffled <- FALSE
[01:29:03.247]                       if (inherits(cond, "message")) {
[01:29:03.247]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:03.247]                         if (muffled) 
[01:29:03.247]                           invokeRestart("muffleMessage")
[01:29:03.247]                       }
[01:29:03.247]                       else if (inherits(cond, "warning")) {
[01:29:03.247]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:03.247]                         if (muffled) 
[01:29:03.247]                           invokeRestart("muffleWarning")
[01:29:03.247]                       }
[01:29:03.247]                       else if (inherits(cond, "condition")) {
[01:29:03.247]                         if (!is.null(pattern)) {
[01:29:03.247]                           computeRestarts <- base::computeRestarts
[01:29:03.247]                           grepl <- base::grepl
[01:29:03.247]                           restarts <- computeRestarts(cond)
[01:29:03.247]                           for (restart in restarts) {
[01:29:03.247]                             name <- restart$name
[01:29:03.247]                             if (is.null(name)) 
[01:29:03.247]                               next
[01:29:03.247]                             if (!grepl(pattern, name)) 
[01:29:03.247]                               next
[01:29:03.247]                             invokeRestart(restart)
[01:29:03.247]                             muffled <- TRUE
[01:29:03.247]                             break
[01:29:03.247]                           }
[01:29:03.247]                         }
[01:29:03.247]                       }
[01:29:03.247]                       invisible(muffled)
[01:29:03.247]                     }
[01:29:03.247]                     muffleCondition(cond, pattern = "^muffle")
[01:29:03.247]                   }
[01:29:03.247]                 }
[01:29:03.247]             }
[01:29:03.247]         }))
[01:29:03.247]     }, error = function(ex) {
[01:29:03.247]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:03.247]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:03.247]                 ...future.rng), started = ...future.startTime, 
[01:29:03.247]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:03.247]             version = "1.8"), class = "FutureResult")
[01:29:03.247]     }, finally = {
[01:29:03.247]         if (!identical(...future.workdir, getwd())) 
[01:29:03.247]             setwd(...future.workdir)
[01:29:03.247]         {
[01:29:03.247]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:03.247]                 ...future.oldOptions$nwarnings <- NULL
[01:29:03.247]             }
[01:29:03.247]             base::options(...future.oldOptions)
[01:29:03.247]             if (.Platform$OS.type == "windows") {
[01:29:03.247]                 old_names <- names(...future.oldEnvVars)
[01:29:03.247]                 envs <- base::Sys.getenv()
[01:29:03.247]                 names <- names(envs)
[01:29:03.247]                 common <- intersect(names, old_names)
[01:29:03.247]                 added <- setdiff(names, old_names)
[01:29:03.247]                 removed <- setdiff(old_names, names)
[01:29:03.247]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:03.247]                   envs[common]]
[01:29:03.247]                 NAMES <- toupper(changed)
[01:29:03.247]                 args <- list()
[01:29:03.247]                 for (kk in seq_along(NAMES)) {
[01:29:03.247]                   name <- changed[[kk]]
[01:29:03.247]                   NAME <- NAMES[[kk]]
[01:29:03.247]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:03.247]                     next
[01:29:03.247]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:03.247]                 }
[01:29:03.247]                 NAMES <- toupper(added)
[01:29:03.247]                 for (kk in seq_along(NAMES)) {
[01:29:03.247]                   name <- added[[kk]]
[01:29:03.247]                   NAME <- NAMES[[kk]]
[01:29:03.247]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:03.247]                     next
[01:29:03.247]                   args[[name]] <- ""
[01:29:03.247]                 }
[01:29:03.247]                 NAMES <- toupper(removed)
[01:29:03.247]                 for (kk in seq_along(NAMES)) {
[01:29:03.247]                   name <- removed[[kk]]
[01:29:03.247]                   NAME <- NAMES[[kk]]
[01:29:03.247]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:03.247]                     next
[01:29:03.247]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:03.247]                 }
[01:29:03.247]                 if (length(args) > 0) 
[01:29:03.247]                   base::do.call(base::Sys.setenv, args = args)
[01:29:03.247]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:03.247]             }
[01:29:03.247]             else {
[01:29:03.247]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:03.247]             }
[01:29:03.247]             {
[01:29:03.247]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:03.247]                   0L) {
[01:29:03.247]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:03.247]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:03.247]                   base::options(opts)
[01:29:03.247]                 }
[01:29:03.247]                 {
[01:29:03.247]                   {
[01:29:03.247]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:03.247]                     NULL
[01:29:03.247]                   }
[01:29:03.247]                   options(future.plan = NULL)
[01:29:03.247]                   if (is.na(NA_character_)) 
[01:29:03.247]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:03.247]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:03.247]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:03.247]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:03.247]                     envir = parent.frame()) 
[01:29:03.247]                   {
[01:29:03.247]                     if (is.function(workers)) 
[01:29:03.247]                       workers <- workers()
[01:29:03.247]                     workers <- structure(as.integer(workers), 
[01:29:03.247]                       class = class(workers))
[01:29:03.247]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:03.247]                       workers >= 1)
[01:29:03.247]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:03.247]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:03.247]                     }
[01:29:03.247]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:03.247]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:03.247]                       envir = envir)
[01:29:03.247]                     if (!future$lazy) 
[01:29:03.247]                       future <- run(future)
[01:29:03.247]                     invisible(future)
[01:29:03.247]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:03.247]                 }
[01:29:03.247]             }
[01:29:03.247]         }
[01:29:03.247]     })
[01:29:03.247]     if (TRUE) {
[01:29:03.247]         base::sink(type = "output", split = FALSE)
[01:29:03.247]         if (TRUE) {
[01:29:03.247]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:03.247]         }
[01:29:03.247]         else {
[01:29:03.247]             ...future.result["stdout"] <- base::list(NULL)
[01:29:03.247]         }
[01:29:03.247]         base::close(...future.stdout)
[01:29:03.247]         ...future.stdout <- NULL
[01:29:03.247]     }
[01:29:03.247]     ...future.result$conditions <- ...future.conditions
[01:29:03.247]     ...future.result$finished <- base::Sys.time()
[01:29:03.247]     ...future.result
[01:29:03.247] }
[01:29:03.253] MultisessionFuture started
[01:29:03.253] - Launch lazy future ... done
[01:29:03.253] run() for 'MultisessionFuture' ... done
[01:29:03.790] receiveMessageFromWorker() for ClusterFuture ...
[01:29:03.790] - Validating connection of MultisessionFuture
[01:29:03.791] - received message: FutureResult
[01:29:03.791] - Received FutureResult
[01:29:03.791] - Erased future from FutureRegistry
[01:29:03.791] result() for ClusterFuture ...
[01:29:03.792] - result already collected: FutureResult
[01:29:03.792] result() for ClusterFuture ... done
[01:29:03.792] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:03.792] A MultisessionFuture was resolved (result was not collected)
- w/ exception ...
[01:29:03.792] getGlobalsAndPackages() ...
[01:29:03.793] Searching for globals...
[01:29:03.794] - globals found: [2] 'list', 'stop'
[01:29:03.794] Searching for globals ... DONE
[01:29:03.794] Resolving globals: FALSE
[01:29:03.794] 
[01:29:03.795] 
[01:29:03.795] getGlobalsAndPackages() ... DONE
[01:29:03.795] run() for 'Future' ...
[01:29:03.795] - state: 'created'
[01:29:03.796] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:03.811] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:03.812] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:03.812]   - Field: 'node'
[01:29:03.812]   - Field: 'label'
[01:29:03.812]   - Field: 'local'
[01:29:03.813]   - Field: 'owner'
[01:29:03.813]   - Field: 'envir'
[01:29:03.813]   - Field: 'workers'
[01:29:03.813]   - Field: 'packages'
[01:29:03.813]   - Field: 'gc'
[01:29:03.814]   - Field: 'conditions'
[01:29:03.814]   - Field: 'persistent'
[01:29:03.814]   - Field: 'expr'
[01:29:03.814]   - Field: 'uuid'
[01:29:03.814]   - Field: 'seed'
[01:29:03.815]   - Field: 'version'
[01:29:03.815]   - Field: 'result'
[01:29:03.815]   - Field: 'asynchronous'
[01:29:03.815]   - Field: 'calls'
[01:29:03.815]   - Field: 'globals'
[01:29:03.815]   - Field: 'stdout'
[01:29:03.816]   - Field: 'earlySignal'
[01:29:03.816]   - Field: 'lazy'
[01:29:03.816]   - Field: 'state'
[01:29:03.816] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:03.816] - Launch lazy future ...
[01:29:03.817] Packages needed by the future expression (n = 0): <none>
[01:29:03.817] Packages needed by future strategies (n = 0): <none>
[01:29:03.818] {
[01:29:03.818]     {
[01:29:03.818]         {
[01:29:03.818]             ...future.startTime <- base::Sys.time()
[01:29:03.818]             {
[01:29:03.818]                 {
[01:29:03.818]                   {
[01:29:03.818]                     {
[01:29:03.818]                       base::local({
[01:29:03.818]                         has_future <- base::requireNamespace("future", 
[01:29:03.818]                           quietly = TRUE)
[01:29:03.818]                         if (has_future) {
[01:29:03.818]                           ns <- base::getNamespace("future")
[01:29:03.818]                           version <- ns[[".package"]][["version"]]
[01:29:03.818]                           if (is.null(version)) 
[01:29:03.818]                             version <- utils::packageVersion("future")
[01:29:03.818]                         }
[01:29:03.818]                         else {
[01:29:03.818]                           version <- NULL
[01:29:03.818]                         }
[01:29:03.818]                         if (!has_future || version < "1.8.0") {
[01:29:03.818]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:03.818]                             "", base::R.version$version.string), 
[01:29:03.818]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:03.818]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:03.818]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:03.818]                               "release", "version")], collapse = " "), 
[01:29:03.818]                             hostname = base::Sys.info()[["nodename"]])
[01:29:03.818]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:03.818]                             info)
[01:29:03.818]                           info <- base::paste(info, collapse = "; ")
[01:29:03.818]                           if (!has_future) {
[01:29:03.818]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:03.818]                               info)
[01:29:03.818]                           }
[01:29:03.818]                           else {
[01:29:03.818]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:03.818]                               info, version)
[01:29:03.818]                           }
[01:29:03.818]                           base::stop(msg)
[01:29:03.818]                         }
[01:29:03.818]                       })
[01:29:03.818]                     }
[01:29:03.818]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:03.818]                     base::options(mc.cores = 1L)
[01:29:03.818]                   }
[01:29:03.818]                   options(future.plan = NULL)
[01:29:03.818]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:03.818]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:03.818]                 }
[01:29:03.818]                 ...future.workdir <- getwd()
[01:29:03.818]             }
[01:29:03.818]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:03.818]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:03.818]         }
[01:29:03.818]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:03.818]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:03.818]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:03.818]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:03.818]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:03.818]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:03.818]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:03.818]             base::names(...future.oldOptions))
[01:29:03.818]     }
[01:29:03.818]     if (FALSE) {
[01:29:03.818]     }
[01:29:03.818]     else {
[01:29:03.818]         if (TRUE) {
[01:29:03.818]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:03.818]                 open = "w")
[01:29:03.818]         }
[01:29:03.818]         else {
[01:29:03.818]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:03.818]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:03.818]         }
[01:29:03.818]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:03.818]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:03.818]             base::sink(type = "output", split = FALSE)
[01:29:03.818]             base::close(...future.stdout)
[01:29:03.818]         }, add = TRUE)
[01:29:03.818]     }
[01:29:03.818]     ...future.frame <- base::sys.nframe()
[01:29:03.818]     ...future.conditions <- base::list()
[01:29:03.818]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:03.818]     if (FALSE) {
[01:29:03.818]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:03.818]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:03.818]     }
[01:29:03.818]     ...future.result <- base::tryCatch({
[01:29:03.818]         base::withCallingHandlers({
[01:29:03.818]             ...future.value <- base::withVisible(base::local({
[01:29:03.818]                 ...future.makeSendCondition <- base::local({
[01:29:03.818]                   sendCondition <- NULL
[01:29:03.818]                   function(frame = 1L) {
[01:29:03.818]                     if (is.function(sendCondition)) 
[01:29:03.818]                       return(sendCondition)
[01:29:03.818]                     ns <- getNamespace("parallel")
[01:29:03.818]                     if (exists("sendData", mode = "function", 
[01:29:03.818]                       envir = ns)) {
[01:29:03.818]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:03.818]                         envir = ns)
[01:29:03.818]                       envir <- sys.frame(frame)
[01:29:03.818]                       master <- NULL
[01:29:03.818]                       while (!identical(envir, .GlobalEnv) && 
[01:29:03.818]                         !identical(envir, emptyenv())) {
[01:29:03.818]                         if (exists("master", mode = "list", envir = envir, 
[01:29:03.818]                           inherits = FALSE)) {
[01:29:03.818]                           master <- get("master", mode = "list", 
[01:29:03.818]                             envir = envir, inherits = FALSE)
[01:29:03.818]                           if (inherits(master, c("SOCKnode", 
[01:29:03.818]                             "SOCK0node"))) {
[01:29:03.818]                             sendCondition <<- function(cond) {
[01:29:03.818]                               data <- list(type = "VALUE", value = cond, 
[01:29:03.818]                                 success = TRUE)
[01:29:03.818]                               parallel_sendData(master, data)
[01:29:03.818]                             }
[01:29:03.818]                             return(sendCondition)
[01:29:03.818]                           }
[01:29:03.818]                         }
[01:29:03.818]                         frame <- frame + 1L
[01:29:03.818]                         envir <- sys.frame(frame)
[01:29:03.818]                       }
[01:29:03.818]                     }
[01:29:03.818]                     sendCondition <<- function(cond) NULL
[01:29:03.818]                   }
[01:29:03.818]                 })
[01:29:03.818]                 withCallingHandlers({
[01:29:03.818]                   list(a = 1, b = 42L, c = stop("Nah!"))
[01:29:03.818]                 }, immediateCondition = function(cond) {
[01:29:03.818]                   sendCondition <- ...future.makeSendCondition()
[01:29:03.818]                   sendCondition(cond)
[01:29:03.818]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:03.818]                   {
[01:29:03.818]                     inherits <- base::inherits
[01:29:03.818]                     invokeRestart <- base::invokeRestart
[01:29:03.818]                     is.null <- base::is.null
[01:29:03.818]                     muffled <- FALSE
[01:29:03.818]                     if (inherits(cond, "message")) {
[01:29:03.818]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:03.818]                       if (muffled) 
[01:29:03.818]                         invokeRestart("muffleMessage")
[01:29:03.818]                     }
[01:29:03.818]                     else if (inherits(cond, "warning")) {
[01:29:03.818]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:03.818]                       if (muffled) 
[01:29:03.818]                         invokeRestart("muffleWarning")
[01:29:03.818]                     }
[01:29:03.818]                     else if (inherits(cond, "condition")) {
[01:29:03.818]                       if (!is.null(pattern)) {
[01:29:03.818]                         computeRestarts <- base::computeRestarts
[01:29:03.818]                         grepl <- base::grepl
[01:29:03.818]                         restarts <- computeRestarts(cond)
[01:29:03.818]                         for (restart in restarts) {
[01:29:03.818]                           name <- restart$name
[01:29:03.818]                           if (is.null(name)) 
[01:29:03.818]                             next
[01:29:03.818]                           if (!grepl(pattern, name)) 
[01:29:03.818]                             next
[01:29:03.818]                           invokeRestart(restart)
[01:29:03.818]                           muffled <- TRUE
[01:29:03.818]                           break
[01:29:03.818]                         }
[01:29:03.818]                       }
[01:29:03.818]                     }
[01:29:03.818]                     invisible(muffled)
[01:29:03.818]                   }
[01:29:03.818]                   muffleCondition(cond)
[01:29:03.818]                 })
[01:29:03.818]             }))
[01:29:03.818]             future::FutureResult(value = ...future.value$value, 
[01:29:03.818]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:03.818]                   ...future.rng), globalenv = if (FALSE) 
[01:29:03.818]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:03.818]                     ...future.globalenv.names))
[01:29:03.818]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:03.818]         }, condition = base::local({
[01:29:03.818]             c <- base::c
[01:29:03.818]             inherits <- base::inherits
[01:29:03.818]             invokeRestart <- base::invokeRestart
[01:29:03.818]             length <- base::length
[01:29:03.818]             list <- base::list
[01:29:03.818]             seq.int <- base::seq.int
[01:29:03.818]             signalCondition <- base::signalCondition
[01:29:03.818]             sys.calls <- base::sys.calls
[01:29:03.818]             `[[` <- base::`[[`
[01:29:03.818]             `+` <- base::`+`
[01:29:03.818]             `<<-` <- base::`<<-`
[01:29:03.818]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:03.818]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:03.818]                   3L)]
[01:29:03.818]             }
[01:29:03.818]             function(cond) {
[01:29:03.818]                 is_error <- inherits(cond, "error")
[01:29:03.818]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:03.818]                   NULL)
[01:29:03.818]                 if (is_error) {
[01:29:03.818]                   sessionInformation <- function() {
[01:29:03.818]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:03.818]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:03.818]                       search = base::search(), system = base::Sys.info())
[01:29:03.818]                   }
[01:29:03.818]                   ...future.conditions[[length(...future.conditions) + 
[01:29:03.818]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:03.818]                     cond$call), session = sessionInformation(), 
[01:29:03.818]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:03.818]                   signalCondition(cond)
[01:29:03.818]                 }
[01:29:03.818]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:03.818]                 "immediateCondition"))) {
[01:29:03.818]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:03.818]                   ...future.conditions[[length(...future.conditions) + 
[01:29:03.818]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:03.818]                   if (TRUE && !signal) {
[01:29:03.818]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:03.818]                     {
[01:29:03.818]                       inherits <- base::inherits
[01:29:03.818]                       invokeRestart <- base::invokeRestart
[01:29:03.818]                       is.null <- base::is.null
[01:29:03.818]                       muffled <- FALSE
[01:29:03.818]                       if (inherits(cond, "message")) {
[01:29:03.818]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:03.818]                         if (muffled) 
[01:29:03.818]                           invokeRestart("muffleMessage")
[01:29:03.818]                       }
[01:29:03.818]                       else if (inherits(cond, "warning")) {
[01:29:03.818]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:03.818]                         if (muffled) 
[01:29:03.818]                           invokeRestart("muffleWarning")
[01:29:03.818]                       }
[01:29:03.818]                       else if (inherits(cond, "condition")) {
[01:29:03.818]                         if (!is.null(pattern)) {
[01:29:03.818]                           computeRestarts <- base::computeRestarts
[01:29:03.818]                           grepl <- base::grepl
[01:29:03.818]                           restarts <- computeRestarts(cond)
[01:29:03.818]                           for (restart in restarts) {
[01:29:03.818]                             name <- restart$name
[01:29:03.818]                             if (is.null(name)) 
[01:29:03.818]                               next
[01:29:03.818]                             if (!grepl(pattern, name)) 
[01:29:03.818]                               next
[01:29:03.818]                             invokeRestart(restart)
[01:29:03.818]                             muffled <- TRUE
[01:29:03.818]                             break
[01:29:03.818]                           }
[01:29:03.818]                         }
[01:29:03.818]                       }
[01:29:03.818]                       invisible(muffled)
[01:29:03.818]                     }
[01:29:03.818]                     muffleCondition(cond, pattern = "^muffle")
[01:29:03.818]                   }
[01:29:03.818]                 }
[01:29:03.818]                 else {
[01:29:03.818]                   if (TRUE) {
[01:29:03.818]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:03.818]                     {
[01:29:03.818]                       inherits <- base::inherits
[01:29:03.818]                       invokeRestart <- base::invokeRestart
[01:29:03.818]                       is.null <- base::is.null
[01:29:03.818]                       muffled <- FALSE
[01:29:03.818]                       if (inherits(cond, "message")) {
[01:29:03.818]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:03.818]                         if (muffled) 
[01:29:03.818]                           invokeRestart("muffleMessage")
[01:29:03.818]                       }
[01:29:03.818]                       else if (inherits(cond, "warning")) {
[01:29:03.818]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:03.818]                         if (muffled) 
[01:29:03.818]                           invokeRestart("muffleWarning")
[01:29:03.818]                       }
[01:29:03.818]                       else if (inherits(cond, "condition")) {
[01:29:03.818]                         if (!is.null(pattern)) {
[01:29:03.818]                           computeRestarts <- base::computeRestarts
[01:29:03.818]                           grepl <- base::grepl
[01:29:03.818]                           restarts <- computeRestarts(cond)
[01:29:03.818]                           for (restart in restarts) {
[01:29:03.818]                             name <- restart$name
[01:29:03.818]                             if (is.null(name)) 
[01:29:03.818]                               next
[01:29:03.818]                             if (!grepl(pattern, name)) 
[01:29:03.818]                               next
[01:29:03.818]                             invokeRestart(restart)
[01:29:03.818]                             muffled <- TRUE
[01:29:03.818]                             break
[01:29:03.818]                           }
[01:29:03.818]                         }
[01:29:03.818]                       }
[01:29:03.818]                       invisible(muffled)
[01:29:03.818]                     }
[01:29:03.818]                     muffleCondition(cond, pattern = "^muffle")
[01:29:03.818]                   }
[01:29:03.818]                 }
[01:29:03.818]             }
[01:29:03.818]         }))
[01:29:03.818]     }, error = function(ex) {
[01:29:03.818]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:03.818]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:03.818]                 ...future.rng), started = ...future.startTime, 
[01:29:03.818]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:03.818]             version = "1.8"), class = "FutureResult")
[01:29:03.818]     }, finally = {
[01:29:03.818]         if (!identical(...future.workdir, getwd())) 
[01:29:03.818]             setwd(...future.workdir)
[01:29:03.818]         {
[01:29:03.818]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:03.818]                 ...future.oldOptions$nwarnings <- NULL
[01:29:03.818]             }
[01:29:03.818]             base::options(...future.oldOptions)
[01:29:03.818]             if (.Platform$OS.type == "windows") {
[01:29:03.818]                 old_names <- names(...future.oldEnvVars)
[01:29:03.818]                 envs <- base::Sys.getenv()
[01:29:03.818]                 names <- names(envs)
[01:29:03.818]                 common <- intersect(names, old_names)
[01:29:03.818]                 added <- setdiff(names, old_names)
[01:29:03.818]                 removed <- setdiff(old_names, names)
[01:29:03.818]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:03.818]                   envs[common]]
[01:29:03.818]                 NAMES <- toupper(changed)
[01:29:03.818]                 args <- list()
[01:29:03.818]                 for (kk in seq_along(NAMES)) {
[01:29:03.818]                   name <- changed[[kk]]
[01:29:03.818]                   NAME <- NAMES[[kk]]
[01:29:03.818]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:03.818]                     next
[01:29:03.818]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:03.818]                 }
[01:29:03.818]                 NAMES <- toupper(added)
[01:29:03.818]                 for (kk in seq_along(NAMES)) {
[01:29:03.818]                   name <- added[[kk]]
[01:29:03.818]                   NAME <- NAMES[[kk]]
[01:29:03.818]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:03.818]                     next
[01:29:03.818]                   args[[name]] <- ""
[01:29:03.818]                 }
[01:29:03.818]                 NAMES <- toupper(removed)
[01:29:03.818]                 for (kk in seq_along(NAMES)) {
[01:29:03.818]                   name <- removed[[kk]]
[01:29:03.818]                   NAME <- NAMES[[kk]]
[01:29:03.818]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:03.818]                     next
[01:29:03.818]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:03.818]                 }
[01:29:03.818]                 if (length(args) > 0) 
[01:29:03.818]                   base::do.call(base::Sys.setenv, args = args)
[01:29:03.818]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:03.818]             }
[01:29:03.818]             else {
[01:29:03.818]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:03.818]             }
[01:29:03.818]             {
[01:29:03.818]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:03.818]                   0L) {
[01:29:03.818]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:03.818]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:03.818]                   base::options(opts)
[01:29:03.818]                 }
[01:29:03.818]                 {
[01:29:03.818]                   {
[01:29:03.818]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:03.818]                     NULL
[01:29:03.818]                   }
[01:29:03.818]                   options(future.plan = NULL)
[01:29:03.818]                   if (is.na(NA_character_)) 
[01:29:03.818]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:03.818]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:03.818]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:03.818]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:03.818]                     envir = parent.frame()) 
[01:29:03.818]                   {
[01:29:03.818]                     if (is.function(workers)) 
[01:29:03.818]                       workers <- workers()
[01:29:03.818]                     workers <- structure(as.integer(workers), 
[01:29:03.818]                       class = class(workers))
[01:29:03.818]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:03.818]                       workers >= 1)
[01:29:03.818]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:03.818]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:03.818]                     }
[01:29:03.818]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:03.818]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:03.818]                       envir = envir)
[01:29:03.818]                     if (!future$lazy) 
[01:29:03.818]                       future <- run(future)
[01:29:03.818]                     invisible(future)
[01:29:03.818]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:03.818]                 }
[01:29:03.818]             }
[01:29:03.818]         }
[01:29:03.818]     })
[01:29:03.818]     if (TRUE) {
[01:29:03.818]         base::sink(type = "output", split = FALSE)
[01:29:03.818]         if (TRUE) {
[01:29:03.818]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:03.818]         }
[01:29:03.818]         else {
[01:29:03.818]             ...future.result["stdout"] <- base::list(NULL)
[01:29:03.818]         }
[01:29:03.818]         base::close(...future.stdout)
[01:29:03.818]         ...future.stdout <- NULL
[01:29:03.818]     }
[01:29:03.818]     ...future.result$conditions <- ...future.conditions
[01:29:03.818]     ...future.result$finished <- base::Sys.time()
[01:29:03.818]     ...future.result
[01:29:03.818] }
[01:29:03.824] MultisessionFuture started
[01:29:03.824] - Launch lazy future ... done
[01:29:03.824] run() for 'MultisessionFuture' ... done
[01:29:03.848] receiveMessageFromWorker() for ClusterFuture ...
[01:29:03.849] - Validating connection of MultisessionFuture
[01:29:03.849] - received message: FutureResult
[01:29:03.850] - Received FutureResult
[01:29:03.850] - Erased future from FutureRegistry
[01:29:03.850] result() for ClusterFuture ...
[01:29:03.850] - result already collected: FutureResult
[01:29:03.850] result() for ClusterFuture ... done
[01:29:03.851] signalConditions() ...
[01:29:03.851]  - include = 'immediateCondition'
[01:29:03.851]  - exclude = 
[01:29:03.851]  - resignal = FALSE
[01:29:03.851]  - Number of conditions: 1
[01:29:03.852] signalConditions() ... done
[01:29:03.852] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:03.852] A MultisessionFuture was resolved (result was not collected)
[01:29:03.852] getGlobalsAndPackages() ...
[01:29:03.852] Searching for globals...
[01:29:03.853] - globals found: [2] 'list', 'stop'
[01:29:03.854] Searching for globals ... DONE
[01:29:03.854] Resolving globals: FALSE
[01:29:03.854] 
[01:29:03.854] 
[01:29:03.855] getGlobalsAndPackages() ... DONE
[01:29:03.855] run() for 'Future' ...
[01:29:03.855] - state: 'created'
[01:29:03.855] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:03.871] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:03.872] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:03.872]   - Field: 'node'
[01:29:03.872]   - Field: 'label'
[01:29:03.873]   - Field: 'local'
[01:29:03.873]   - Field: 'owner'
[01:29:03.873]   - Field: 'envir'
[01:29:03.873]   - Field: 'workers'
[01:29:03.874]   - Field: 'packages'
[01:29:03.874]   - Field: 'gc'
[01:29:03.874]   - Field: 'conditions'
[01:29:03.875]   - Field: 'persistent'
[01:29:03.875]   - Field: 'expr'
[01:29:03.875]   - Field: 'uuid'
[01:29:03.875]   - Field: 'seed'
[01:29:03.876]   - Field: 'version'
[01:29:03.876]   - Field: 'result'
[01:29:03.876]   - Field: 'asynchronous'
[01:29:03.876]   - Field: 'calls'
[01:29:03.877]   - Field: 'globals'
[01:29:03.877]   - Field: 'stdout'
[01:29:03.877]   - Field: 'earlySignal'
[01:29:03.877]   - Field: 'lazy'
[01:29:03.878]   - Field: 'state'
[01:29:03.878] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:03.878] - Launch lazy future ...
[01:29:03.879] Packages needed by the future expression (n = 0): <none>
[01:29:03.879] Packages needed by future strategies (n = 0): <none>
[01:29:03.881] {
[01:29:03.881]     {
[01:29:03.881]         {
[01:29:03.881]             ...future.startTime <- base::Sys.time()
[01:29:03.881]             {
[01:29:03.881]                 {
[01:29:03.881]                   {
[01:29:03.881]                     {
[01:29:03.881]                       base::local({
[01:29:03.881]                         has_future <- base::requireNamespace("future", 
[01:29:03.881]                           quietly = TRUE)
[01:29:03.881]                         if (has_future) {
[01:29:03.881]                           ns <- base::getNamespace("future")
[01:29:03.881]                           version <- ns[[".package"]][["version"]]
[01:29:03.881]                           if (is.null(version)) 
[01:29:03.881]                             version <- utils::packageVersion("future")
[01:29:03.881]                         }
[01:29:03.881]                         else {
[01:29:03.881]                           version <- NULL
[01:29:03.881]                         }
[01:29:03.881]                         if (!has_future || version < "1.8.0") {
[01:29:03.881]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:03.881]                             "", base::R.version$version.string), 
[01:29:03.881]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:03.881]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:03.881]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:03.881]                               "release", "version")], collapse = " "), 
[01:29:03.881]                             hostname = base::Sys.info()[["nodename"]])
[01:29:03.881]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:03.881]                             info)
[01:29:03.881]                           info <- base::paste(info, collapse = "; ")
[01:29:03.881]                           if (!has_future) {
[01:29:03.881]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:03.881]                               info)
[01:29:03.881]                           }
[01:29:03.881]                           else {
[01:29:03.881]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:03.881]                               info, version)
[01:29:03.881]                           }
[01:29:03.881]                           base::stop(msg)
[01:29:03.881]                         }
[01:29:03.881]                       })
[01:29:03.881]                     }
[01:29:03.881]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:03.881]                     base::options(mc.cores = 1L)
[01:29:03.881]                   }
[01:29:03.881]                   options(future.plan = NULL)
[01:29:03.881]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:03.881]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:03.881]                 }
[01:29:03.881]                 ...future.workdir <- getwd()
[01:29:03.881]             }
[01:29:03.881]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:03.881]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:03.881]         }
[01:29:03.881]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:03.881]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:03.881]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:03.881]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:03.881]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:03.881]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:03.881]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:03.881]             base::names(...future.oldOptions))
[01:29:03.881]     }
[01:29:03.881]     if (FALSE) {
[01:29:03.881]     }
[01:29:03.881]     else {
[01:29:03.881]         if (TRUE) {
[01:29:03.881]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:03.881]                 open = "w")
[01:29:03.881]         }
[01:29:03.881]         else {
[01:29:03.881]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:03.881]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:03.881]         }
[01:29:03.881]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:03.881]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:03.881]             base::sink(type = "output", split = FALSE)
[01:29:03.881]             base::close(...future.stdout)
[01:29:03.881]         }, add = TRUE)
[01:29:03.881]     }
[01:29:03.881]     ...future.frame <- base::sys.nframe()
[01:29:03.881]     ...future.conditions <- base::list()
[01:29:03.881]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:03.881]     if (FALSE) {
[01:29:03.881]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:03.881]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:03.881]     }
[01:29:03.881]     ...future.result <- base::tryCatch({
[01:29:03.881]         base::withCallingHandlers({
[01:29:03.881]             ...future.value <- base::withVisible(base::local({
[01:29:03.881]                 ...future.makeSendCondition <- base::local({
[01:29:03.881]                   sendCondition <- NULL
[01:29:03.881]                   function(frame = 1L) {
[01:29:03.881]                     if (is.function(sendCondition)) 
[01:29:03.881]                       return(sendCondition)
[01:29:03.881]                     ns <- getNamespace("parallel")
[01:29:03.881]                     if (exists("sendData", mode = "function", 
[01:29:03.881]                       envir = ns)) {
[01:29:03.881]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:03.881]                         envir = ns)
[01:29:03.881]                       envir <- sys.frame(frame)
[01:29:03.881]                       master <- NULL
[01:29:03.881]                       while (!identical(envir, .GlobalEnv) && 
[01:29:03.881]                         !identical(envir, emptyenv())) {
[01:29:03.881]                         if (exists("master", mode = "list", envir = envir, 
[01:29:03.881]                           inherits = FALSE)) {
[01:29:03.881]                           master <- get("master", mode = "list", 
[01:29:03.881]                             envir = envir, inherits = FALSE)
[01:29:03.881]                           if (inherits(master, c("SOCKnode", 
[01:29:03.881]                             "SOCK0node"))) {
[01:29:03.881]                             sendCondition <<- function(cond) {
[01:29:03.881]                               data <- list(type = "VALUE", value = cond, 
[01:29:03.881]                                 success = TRUE)
[01:29:03.881]                               parallel_sendData(master, data)
[01:29:03.881]                             }
[01:29:03.881]                             return(sendCondition)
[01:29:03.881]                           }
[01:29:03.881]                         }
[01:29:03.881]                         frame <- frame + 1L
[01:29:03.881]                         envir <- sys.frame(frame)
[01:29:03.881]                       }
[01:29:03.881]                     }
[01:29:03.881]                     sendCondition <<- function(cond) NULL
[01:29:03.881]                   }
[01:29:03.881]                 })
[01:29:03.881]                 withCallingHandlers({
[01:29:03.881]                   list(a = 1, b = 42L, c = stop("Nah!"))
[01:29:03.881]                 }, immediateCondition = function(cond) {
[01:29:03.881]                   sendCondition <- ...future.makeSendCondition()
[01:29:03.881]                   sendCondition(cond)
[01:29:03.881]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:03.881]                   {
[01:29:03.881]                     inherits <- base::inherits
[01:29:03.881]                     invokeRestart <- base::invokeRestart
[01:29:03.881]                     is.null <- base::is.null
[01:29:03.881]                     muffled <- FALSE
[01:29:03.881]                     if (inherits(cond, "message")) {
[01:29:03.881]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:03.881]                       if (muffled) 
[01:29:03.881]                         invokeRestart("muffleMessage")
[01:29:03.881]                     }
[01:29:03.881]                     else if (inherits(cond, "warning")) {
[01:29:03.881]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:03.881]                       if (muffled) 
[01:29:03.881]                         invokeRestart("muffleWarning")
[01:29:03.881]                     }
[01:29:03.881]                     else if (inherits(cond, "condition")) {
[01:29:03.881]                       if (!is.null(pattern)) {
[01:29:03.881]                         computeRestarts <- base::computeRestarts
[01:29:03.881]                         grepl <- base::grepl
[01:29:03.881]                         restarts <- computeRestarts(cond)
[01:29:03.881]                         for (restart in restarts) {
[01:29:03.881]                           name <- restart$name
[01:29:03.881]                           if (is.null(name)) 
[01:29:03.881]                             next
[01:29:03.881]                           if (!grepl(pattern, name)) 
[01:29:03.881]                             next
[01:29:03.881]                           invokeRestart(restart)
[01:29:03.881]                           muffled <- TRUE
[01:29:03.881]                           break
[01:29:03.881]                         }
[01:29:03.881]                       }
[01:29:03.881]                     }
[01:29:03.881]                     invisible(muffled)
[01:29:03.881]                   }
[01:29:03.881]                   muffleCondition(cond)
[01:29:03.881]                 })
[01:29:03.881]             }))
[01:29:03.881]             future::FutureResult(value = ...future.value$value, 
[01:29:03.881]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:03.881]                   ...future.rng), globalenv = if (FALSE) 
[01:29:03.881]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:03.881]                     ...future.globalenv.names))
[01:29:03.881]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:03.881]         }, condition = base::local({
[01:29:03.881]             c <- base::c
[01:29:03.881]             inherits <- base::inherits
[01:29:03.881]             invokeRestart <- base::invokeRestart
[01:29:03.881]             length <- base::length
[01:29:03.881]             list <- base::list
[01:29:03.881]             seq.int <- base::seq.int
[01:29:03.881]             signalCondition <- base::signalCondition
[01:29:03.881]             sys.calls <- base::sys.calls
[01:29:03.881]             `[[` <- base::`[[`
[01:29:03.881]             `+` <- base::`+`
[01:29:03.881]             `<<-` <- base::`<<-`
[01:29:03.881]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:03.881]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:03.881]                   3L)]
[01:29:03.881]             }
[01:29:03.881]             function(cond) {
[01:29:03.881]                 is_error <- inherits(cond, "error")
[01:29:03.881]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:03.881]                   NULL)
[01:29:03.881]                 if (is_error) {
[01:29:03.881]                   sessionInformation <- function() {
[01:29:03.881]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:03.881]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:03.881]                       search = base::search(), system = base::Sys.info())
[01:29:03.881]                   }
[01:29:03.881]                   ...future.conditions[[length(...future.conditions) + 
[01:29:03.881]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:03.881]                     cond$call), session = sessionInformation(), 
[01:29:03.881]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:03.881]                   signalCondition(cond)
[01:29:03.881]                 }
[01:29:03.881]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:03.881]                 "immediateCondition"))) {
[01:29:03.881]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:03.881]                   ...future.conditions[[length(...future.conditions) + 
[01:29:03.881]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:03.881]                   if (TRUE && !signal) {
[01:29:03.881]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:03.881]                     {
[01:29:03.881]                       inherits <- base::inherits
[01:29:03.881]                       invokeRestart <- base::invokeRestart
[01:29:03.881]                       is.null <- base::is.null
[01:29:03.881]                       muffled <- FALSE
[01:29:03.881]                       if (inherits(cond, "message")) {
[01:29:03.881]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:03.881]                         if (muffled) 
[01:29:03.881]                           invokeRestart("muffleMessage")
[01:29:03.881]                       }
[01:29:03.881]                       else if (inherits(cond, "warning")) {
[01:29:03.881]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:03.881]                         if (muffled) 
[01:29:03.881]                           invokeRestart("muffleWarning")
[01:29:03.881]                       }
[01:29:03.881]                       else if (inherits(cond, "condition")) {
[01:29:03.881]                         if (!is.null(pattern)) {
[01:29:03.881]                           computeRestarts <- base::computeRestarts
[01:29:03.881]                           grepl <- base::grepl
[01:29:03.881]                           restarts <- computeRestarts(cond)
[01:29:03.881]                           for (restart in restarts) {
[01:29:03.881]                             name <- restart$name
[01:29:03.881]                             if (is.null(name)) 
[01:29:03.881]                               next
[01:29:03.881]                             if (!grepl(pattern, name)) 
[01:29:03.881]                               next
[01:29:03.881]                             invokeRestart(restart)
[01:29:03.881]                             muffled <- TRUE
[01:29:03.881]                             break
[01:29:03.881]                           }
[01:29:03.881]                         }
[01:29:03.881]                       }
[01:29:03.881]                       invisible(muffled)
[01:29:03.881]                     }
[01:29:03.881]                     muffleCondition(cond, pattern = "^muffle")
[01:29:03.881]                   }
[01:29:03.881]                 }
[01:29:03.881]                 else {
[01:29:03.881]                   if (TRUE) {
[01:29:03.881]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:03.881]                     {
[01:29:03.881]                       inherits <- base::inherits
[01:29:03.881]                       invokeRestart <- base::invokeRestart
[01:29:03.881]                       is.null <- base::is.null
[01:29:03.881]                       muffled <- FALSE
[01:29:03.881]                       if (inherits(cond, "message")) {
[01:29:03.881]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:03.881]                         if (muffled) 
[01:29:03.881]                           invokeRestart("muffleMessage")
[01:29:03.881]                       }
[01:29:03.881]                       else if (inherits(cond, "warning")) {
[01:29:03.881]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:03.881]                         if (muffled) 
[01:29:03.881]                           invokeRestart("muffleWarning")
[01:29:03.881]                       }
[01:29:03.881]                       else if (inherits(cond, "condition")) {
[01:29:03.881]                         if (!is.null(pattern)) {
[01:29:03.881]                           computeRestarts <- base::computeRestarts
[01:29:03.881]                           grepl <- base::grepl
[01:29:03.881]                           restarts <- computeRestarts(cond)
[01:29:03.881]                           for (restart in restarts) {
[01:29:03.881]                             name <- restart$name
[01:29:03.881]                             if (is.null(name)) 
[01:29:03.881]                               next
[01:29:03.881]                             if (!grepl(pattern, name)) 
[01:29:03.881]                               next
[01:29:03.881]                             invokeRestart(restart)
[01:29:03.881]                             muffled <- TRUE
[01:29:03.881]                             break
[01:29:03.881]                           }
[01:29:03.881]                         }
[01:29:03.881]                       }
[01:29:03.881]                       invisible(muffled)
[01:29:03.881]                     }
[01:29:03.881]                     muffleCondition(cond, pattern = "^muffle")
[01:29:03.881]                   }
[01:29:03.881]                 }
[01:29:03.881]             }
[01:29:03.881]         }))
[01:29:03.881]     }, error = function(ex) {
[01:29:03.881]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:03.881]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:03.881]                 ...future.rng), started = ...future.startTime, 
[01:29:03.881]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:03.881]             version = "1.8"), class = "FutureResult")
[01:29:03.881]     }, finally = {
[01:29:03.881]         if (!identical(...future.workdir, getwd())) 
[01:29:03.881]             setwd(...future.workdir)
[01:29:03.881]         {
[01:29:03.881]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:03.881]                 ...future.oldOptions$nwarnings <- NULL
[01:29:03.881]             }
[01:29:03.881]             base::options(...future.oldOptions)
[01:29:03.881]             if (.Platform$OS.type == "windows") {
[01:29:03.881]                 old_names <- names(...future.oldEnvVars)
[01:29:03.881]                 envs <- base::Sys.getenv()
[01:29:03.881]                 names <- names(envs)
[01:29:03.881]                 common <- intersect(names, old_names)
[01:29:03.881]                 added <- setdiff(names, old_names)
[01:29:03.881]                 removed <- setdiff(old_names, names)
[01:29:03.881]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:03.881]                   envs[common]]
[01:29:03.881]                 NAMES <- toupper(changed)
[01:29:03.881]                 args <- list()
[01:29:03.881]                 for (kk in seq_along(NAMES)) {
[01:29:03.881]                   name <- changed[[kk]]
[01:29:03.881]                   NAME <- NAMES[[kk]]
[01:29:03.881]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:03.881]                     next
[01:29:03.881]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:03.881]                 }
[01:29:03.881]                 NAMES <- toupper(added)
[01:29:03.881]                 for (kk in seq_along(NAMES)) {
[01:29:03.881]                   name <- added[[kk]]
[01:29:03.881]                   NAME <- NAMES[[kk]]
[01:29:03.881]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:03.881]                     next
[01:29:03.881]                   args[[name]] <- ""
[01:29:03.881]                 }
[01:29:03.881]                 NAMES <- toupper(removed)
[01:29:03.881]                 for (kk in seq_along(NAMES)) {
[01:29:03.881]                   name <- removed[[kk]]
[01:29:03.881]                   NAME <- NAMES[[kk]]
[01:29:03.881]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:03.881]                     next
[01:29:03.881]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:03.881]                 }
[01:29:03.881]                 if (length(args) > 0) 
[01:29:03.881]                   base::do.call(base::Sys.setenv, args = args)
[01:29:03.881]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:03.881]             }
[01:29:03.881]             else {
[01:29:03.881]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:03.881]             }
[01:29:03.881]             {
[01:29:03.881]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:03.881]                   0L) {
[01:29:03.881]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:03.881]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:03.881]                   base::options(opts)
[01:29:03.881]                 }
[01:29:03.881]                 {
[01:29:03.881]                   {
[01:29:03.881]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:03.881]                     NULL
[01:29:03.881]                   }
[01:29:03.881]                   options(future.plan = NULL)
[01:29:03.881]                   if (is.na(NA_character_)) 
[01:29:03.881]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:03.881]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:03.881]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:03.881]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:03.881]                     envir = parent.frame()) 
[01:29:03.881]                   {
[01:29:03.881]                     if (is.function(workers)) 
[01:29:03.881]                       workers <- workers()
[01:29:03.881]                     workers <- structure(as.integer(workers), 
[01:29:03.881]                       class = class(workers))
[01:29:03.881]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:03.881]                       workers >= 1)
[01:29:03.881]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:03.881]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:03.881]                     }
[01:29:03.881]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:03.881]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:03.881]                       envir = envir)
[01:29:03.881]                     if (!future$lazy) 
[01:29:03.881]                       future <- run(future)
[01:29:03.881]                     invisible(future)
[01:29:03.881]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:03.881]                 }
[01:29:03.881]             }
[01:29:03.881]         }
[01:29:03.881]     })
[01:29:03.881]     if (TRUE) {
[01:29:03.881]         base::sink(type = "output", split = FALSE)
[01:29:03.881]         if (TRUE) {
[01:29:03.881]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:03.881]         }
[01:29:03.881]         else {
[01:29:03.881]             ...future.result["stdout"] <- base::list(NULL)
[01:29:03.881]         }
[01:29:03.881]         base::close(...future.stdout)
[01:29:03.881]         ...future.stdout <- NULL
[01:29:03.881]     }
[01:29:03.881]     ...future.result$conditions <- ...future.conditions
[01:29:03.881]     ...future.result$finished <- base::Sys.time()
[01:29:03.881]     ...future.result
[01:29:03.881] }
[01:29:03.890] MultisessionFuture started
[01:29:03.890] - Launch lazy future ... done
[01:29:03.890] run() for 'MultisessionFuture' ... done
[01:29:03.916] receiveMessageFromWorker() for ClusterFuture ...
[01:29:03.916] - Validating connection of MultisessionFuture
[01:29:03.916] - received message: FutureResult
[01:29:03.917] - Received FutureResult
[01:29:03.917] - Erased future from FutureRegistry
[01:29:03.917] result() for ClusterFuture ...
[01:29:03.917] - result already collected: FutureResult
[01:29:03.917] result() for ClusterFuture ... done
[01:29:03.918] signalConditions() ...
[01:29:03.918]  - include = 'immediateCondition'
[01:29:03.918]  - exclude = 
[01:29:03.918]  - resignal = FALSE
[01:29:03.918]  - Number of conditions: 1
[01:29:03.919] signalConditions() ... done
[01:29:03.919] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:03.919] A MultisessionFuture was resolved (result was not collected)
- result = FALSE, recursive = Inf ... DONE
- result = TRUE, recursive = FALSE ...
[01:29:03.919] getGlobalsAndPackages() ...
[01:29:03.919] Searching for globals...
[01:29:03.921] - globals found: [3] '{', 'Sys.sleep', 'list'
[01:29:03.921] Searching for globals ... DONE
[01:29:03.921] Resolving globals: FALSE
[01:29:03.922] 
[01:29:03.922] 
[01:29:03.922] getGlobalsAndPackages() ... DONE
[01:29:03.923] run() for 'Future' ...
[01:29:03.923] - state: 'created'
[01:29:03.923] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:03.937] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:03.938] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:03.938]   - Field: 'node'
[01:29:03.938]   - Field: 'label'
[01:29:03.938]   - Field: 'local'
[01:29:03.938]   - Field: 'owner'
[01:29:03.939]   - Field: 'envir'
[01:29:03.939]   - Field: 'workers'
[01:29:03.939]   - Field: 'packages'
[01:29:03.939]   - Field: 'gc'
[01:29:03.939]   - Field: 'conditions'
[01:29:03.940]   - Field: 'persistent'
[01:29:03.940]   - Field: 'expr'
[01:29:03.940]   - Field: 'uuid'
[01:29:03.940]   - Field: 'seed'
[01:29:03.940]   - Field: 'version'
[01:29:03.941]   - Field: 'result'
[01:29:03.941]   - Field: 'asynchronous'
[01:29:03.941]   - Field: 'calls'
[01:29:03.941]   - Field: 'globals'
[01:29:03.941]   - Field: 'stdout'
[01:29:03.942]   - Field: 'earlySignal'
[01:29:03.942]   - Field: 'lazy'
[01:29:03.942]   - Field: 'state'
[01:29:03.942] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:03.942] - Launch lazy future ...
[01:29:03.943] Packages needed by the future expression (n = 0): <none>
[01:29:03.943] Packages needed by future strategies (n = 0): <none>
[01:29:03.944] {
[01:29:03.944]     {
[01:29:03.944]         {
[01:29:03.944]             ...future.startTime <- base::Sys.time()
[01:29:03.944]             {
[01:29:03.944]                 {
[01:29:03.944]                   {
[01:29:03.944]                     {
[01:29:03.944]                       base::local({
[01:29:03.944]                         has_future <- base::requireNamespace("future", 
[01:29:03.944]                           quietly = TRUE)
[01:29:03.944]                         if (has_future) {
[01:29:03.944]                           ns <- base::getNamespace("future")
[01:29:03.944]                           version <- ns[[".package"]][["version"]]
[01:29:03.944]                           if (is.null(version)) 
[01:29:03.944]                             version <- utils::packageVersion("future")
[01:29:03.944]                         }
[01:29:03.944]                         else {
[01:29:03.944]                           version <- NULL
[01:29:03.944]                         }
[01:29:03.944]                         if (!has_future || version < "1.8.0") {
[01:29:03.944]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:03.944]                             "", base::R.version$version.string), 
[01:29:03.944]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:03.944]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:03.944]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:03.944]                               "release", "version")], collapse = " "), 
[01:29:03.944]                             hostname = base::Sys.info()[["nodename"]])
[01:29:03.944]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:03.944]                             info)
[01:29:03.944]                           info <- base::paste(info, collapse = "; ")
[01:29:03.944]                           if (!has_future) {
[01:29:03.944]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:03.944]                               info)
[01:29:03.944]                           }
[01:29:03.944]                           else {
[01:29:03.944]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:03.944]                               info, version)
[01:29:03.944]                           }
[01:29:03.944]                           base::stop(msg)
[01:29:03.944]                         }
[01:29:03.944]                       })
[01:29:03.944]                     }
[01:29:03.944]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:03.944]                     base::options(mc.cores = 1L)
[01:29:03.944]                   }
[01:29:03.944]                   options(future.plan = NULL)
[01:29:03.944]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:03.944]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:03.944]                 }
[01:29:03.944]                 ...future.workdir <- getwd()
[01:29:03.944]             }
[01:29:03.944]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:03.944]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:03.944]         }
[01:29:03.944]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:03.944]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:03.944]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:03.944]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:03.944]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:03.944]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:03.944]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:03.944]             base::names(...future.oldOptions))
[01:29:03.944]     }
[01:29:03.944]     if (FALSE) {
[01:29:03.944]     }
[01:29:03.944]     else {
[01:29:03.944]         if (TRUE) {
[01:29:03.944]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:03.944]                 open = "w")
[01:29:03.944]         }
[01:29:03.944]         else {
[01:29:03.944]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:03.944]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:03.944]         }
[01:29:03.944]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:03.944]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:03.944]             base::sink(type = "output", split = FALSE)
[01:29:03.944]             base::close(...future.stdout)
[01:29:03.944]         }, add = TRUE)
[01:29:03.944]     }
[01:29:03.944]     ...future.frame <- base::sys.nframe()
[01:29:03.944]     ...future.conditions <- base::list()
[01:29:03.944]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:03.944]     if (FALSE) {
[01:29:03.944]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:03.944]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:03.944]     }
[01:29:03.944]     ...future.result <- base::tryCatch({
[01:29:03.944]         base::withCallingHandlers({
[01:29:03.944]             ...future.value <- base::withVisible(base::local({
[01:29:03.944]                 ...future.makeSendCondition <- base::local({
[01:29:03.944]                   sendCondition <- NULL
[01:29:03.944]                   function(frame = 1L) {
[01:29:03.944]                     if (is.function(sendCondition)) 
[01:29:03.944]                       return(sendCondition)
[01:29:03.944]                     ns <- getNamespace("parallel")
[01:29:03.944]                     if (exists("sendData", mode = "function", 
[01:29:03.944]                       envir = ns)) {
[01:29:03.944]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:03.944]                         envir = ns)
[01:29:03.944]                       envir <- sys.frame(frame)
[01:29:03.944]                       master <- NULL
[01:29:03.944]                       while (!identical(envir, .GlobalEnv) && 
[01:29:03.944]                         !identical(envir, emptyenv())) {
[01:29:03.944]                         if (exists("master", mode = "list", envir = envir, 
[01:29:03.944]                           inherits = FALSE)) {
[01:29:03.944]                           master <- get("master", mode = "list", 
[01:29:03.944]                             envir = envir, inherits = FALSE)
[01:29:03.944]                           if (inherits(master, c("SOCKnode", 
[01:29:03.944]                             "SOCK0node"))) {
[01:29:03.944]                             sendCondition <<- function(cond) {
[01:29:03.944]                               data <- list(type = "VALUE", value = cond, 
[01:29:03.944]                                 success = TRUE)
[01:29:03.944]                               parallel_sendData(master, data)
[01:29:03.944]                             }
[01:29:03.944]                             return(sendCondition)
[01:29:03.944]                           }
[01:29:03.944]                         }
[01:29:03.944]                         frame <- frame + 1L
[01:29:03.944]                         envir <- sys.frame(frame)
[01:29:03.944]                       }
[01:29:03.944]                     }
[01:29:03.944]                     sendCondition <<- function(cond) NULL
[01:29:03.944]                   }
[01:29:03.944]                 })
[01:29:03.944]                 withCallingHandlers({
[01:29:03.944]                   {
[01:29:03.944]                     Sys.sleep(0.5)
[01:29:03.944]                     list(a = 1, b = 42L)
[01:29:03.944]                   }
[01:29:03.944]                 }, immediateCondition = function(cond) {
[01:29:03.944]                   sendCondition <- ...future.makeSendCondition()
[01:29:03.944]                   sendCondition(cond)
[01:29:03.944]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:03.944]                   {
[01:29:03.944]                     inherits <- base::inherits
[01:29:03.944]                     invokeRestart <- base::invokeRestart
[01:29:03.944]                     is.null <- base::is.null
[01:29:03.944]                     muffled <- FALSE
[01:29:03.944]                     if (inherits(cond, "message")) {
[01:29:03.944]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:03.944]                       if (muffled) 
[01:29:03.944]                         invokeRestart("muffleMessage")
[01:29:03.944]                     }
[01:29:03.944]                     else if (inherits(cond, "warning")) {
[01:29:03.944]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:03.944]                       if (muffled) 
[01:29:03.944]                         invokeRestart("muffleWarning")
[01:29:03.944]                     }
[01:29:03.944]                     else if (inherits(cond, "condition")) {
[01:29:03.944]                       if (!is.null(pattern)) {
[01:29:03.944]                         computeRestarts <- base::computeRestarts
[01:29:03.944]                         grepl <- base::grepl
[01:29:03.944]                         restarts <- computeRestarts(cond)
[01:29:03.944]                         for (restart in restarts) {
[01:29:03.944]                           name <- restart$name
[01:29:03.944]                           if (is.null(name)) 
[01:29:03.944]                             next
[01:29:03.944]                           if (!grepl(pattern, name)) 
[01:29:03.944]                             next
[01:29:03.944]                           invokeRestart(restart)
[01:29:03.944]                           muffled <- TRUE
[01:29:03.944]                           break
[01:29:03.944]                         }
[01:29:03.944]                       }
[01:29:03.944]                     }
[01:29:03.944]                     invisible(muffled)
[01:29:03.944]                   }
[01:29:03.944]                   muffleCondition(cond)
[01:29:03.944]                 })
[01:29:03.944]             }))
[01:29:03.944]             future::FutureResult(value = ...future.value$value, 
[01:29:03.944]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:03.944]                   ...future.rng), globalenv = if (FALSE) 
[01:29:03.944]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:03.944]                     ...future.globalenv.names))
[01:29:03.944]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:03.944]         }, condition = base::local({
[01:29:03.944]             c <- base::c
[01:29:03.944]             inherits <- base::inherits
[01:29:03.944]             invokeRestart <- base::invokeRestart
[01:29:03.944]             length <- base::length
[01:29:03.944]             list <- base::list
[01:29:03.944]             seq.int <- base::seq.int
[01:29:03.944]             signalCondition <- base::signalCondition
[01:29:03.944]             sys.calls <- base::sys.calls
[01:29:03.944]             `[[` <- base::`[[`
[01:29:03.944]             `+` <- base::`+`
[01:29:03.944]             `<<-` <- base::`<<-`
[01:29:03.944]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:03.944]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:03.944]                   3L)]
[01:29:03.944]             }
[01:29:03.944]             function(cond) {
[01:29:03.944]                 is_error <- inherits(cond, "error")
[01:29:03.944]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:03.944]                   NULL)
[01:29:03.944]                 if (is_error) {
[01:29:03.944]                   sessionInformation <- function() {
[01:29:03.944]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:03.944]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:03.944]                       search = base::search(), system = base::Sys.info())
[01:29:03.944]                   }
[01:29:03.944]                   ...future.conditions[[length(...future.conditions) + 
[01:29:03.944]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:03.944]                     cond$call), session = sessionInformation(), 
[01:29:03.944]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:03.944]                   signalCondition(cond)
[01:29:03.944]                 }
[01:29:03.944]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:03.944]                 "immediateCondition"))) {
[01:29:03.944]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:03.944]                   ...future.conditions[[length(...future.conditions) + 
[01:29:03.944]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:03.944]                   if (TRUE && !signal) {
[01:29:03.944]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:03.944]                     {
[01:29:03.944]                       inherits <- base::inherits
[01:29:03.944]                       invokeRestart <- base::invokeRestart
[01:29:03.944]                       is.null <- base::is.null
[01:29:03.944]                       muffled <- FALSE
[01:29:03.944]                       if (inherits(cond, "message")) {
[01:29:03.944]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:03.944]                         if (muffled) 
[01:29:03.944]                           invokeRestart("muffleMessage")
[01:29:03.944]                       }
[01:29:03.944]                       else if (inherits(cond, "warning")) {
[01:29:03.944]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:03.944]                         if (muffled) 
[01:29:03.944]                           invokeRestart("muffleWarning")
[01:29:03.944]                       }
[01:29:03.944]                       else if (inherits(cond, "condition")) {
[01:29:03.944]                         if (!is.null(pattern)) {
[01:29:03.944]                           computeRestarts <- base::computeRestarts
[01:29:03.944]                           grepl <- base::grepl
[01:29:03.944]                           restarts <- computeRestarts(cond)
[01:29:03.944]                           for (restart in restarts) {
[01:29:03.944]                             name <- restart$name
[01:29:03.944]                             if (is.null(name)) 
[01:29:03.944]                               next
[01:29:03.944]                             if (!grepl(pattern, name)) 
[01:29:03.944]                               next
[01:29:03.944]                             invokeRestart(restart)
[01:29:03.944]                             muffled <- TRUE
[01:29:03.944]                             break
[01:29:03.944]                           }
[01:29:03.944]                         }
[01:29:03.944]                       }
[01:29:03.944]                       invisible(muffled)
[01:29:03.944]                     }
[01:29:03.944]                     muffleCondition(cond, pattern = "^muffle")
[01:29:03.944]                   }
[01:29:03.944]                 }
[01:29:03.944]                 else {
[01:29:03.944]                   if (TRUE) {
[01:29:03.944]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:03.944]                     {
[01:29:03.944]                       inherits <- base::inherits
[01:29:03.944]                       invokeRestart <- base::invokeRestart
[01:29:03.944]                       is.null <- base::is.null
[01:29:03.944]                       muffled <- FALSE
[01:29:03.944]                       if (inherits(cond, "message")) {
[01:29:03.944]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:03.944]                         if (muffled) 
[01:29:03.944]                           invokeRestart("muffleMessage")
[01:29:03.944]                       }
[01:29:03.944]                       else if (inherits(cond, "warning")) {
[01:29:03.944]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:03.944]                         if (muffled) 
[01:29:03.944]                           invokeRestart("muffleWarning")
[01:29:03.944]                       }
[01:29:03.944]                       else if (inherits(cond, "condition")) {
[01:29:03.944]                         if (!is.null(pattern)) {
[01:29:03.944]                           computeRestarts <- base::computeRestarts
[01:29:03.944]                           grepl <- base::grepl
[01:29:03.944]                           restarts <- computeRestarts(cond)
[01:29:03.944]                           for (restart in restarts) {
[01:29:03.944]                             name <- restart$name
[01:29:03.944]                             if (is.null(name)) 
[01:29:03.944]                               next
[01:29:03.944]                             if (!grepl(pattern, name)) 
[01:29:03.944]                               next
[01:29:03.944]                             invokeRestart(restart)
[01:29:03.944]                             muffled <- TRUE
[01:29:03.944]                             break
[01:29:03.944]                           }
[01:29:03.944]                         }
[01:29:03.944]                       }
[01:29:03.944]                       invisible(muffled)
[01:29:03.944]                     }
[01:29:03.944]                     muffleCondition(cond, pattern = "^muffle")
[01:29:03.944]                   }
[01:29:03.944]                 }
[01:29:03.944]             }
[01:29:03.944]         }))
[01:29:03.944]     }, error = function(ex) {
[01:29:03.944]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:03.944]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:03.944]                 ...future.rng), started = ...future.startTime, 
[01:29:03.944]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:03.944]             version = "1.8"), class = "FutureResult")
[01:29:03.944]     }, finally = {
[01:29:03.944]         if (!identical(...future.workdir, getwd())) 
[01:29:03.944]             setwd(...future.workdir)
[01:29:03.944]         {
[01:29:03.944]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:03.944]                 ...future.oldOptions$nwarnings <- NULL
[01:29:03.944]             }
[01:29:03.944]             base::options(...future.oldOptions)
[01:29:03.944]             if (.Platform$OS.type == "windows") {
[01:29:03.944]                 old_names <- names(...future.oldEnvVars)
[01:29:03.944]                 envs <- base::Sys.getenv()
[01:29:03.944]                 names <- names(envs)
[01:29:03.944]                 common <- intersect(names, old_names)
[01:29:03.944]                 added <- setdiff(names, old_names)
[01:29:03.944]                 removed <- setdiff(old_names, names)
[01:29:03.944]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:03.944]                   envs[common]]
[01:29:03.944]                 NAMES <- toupper(changed)
[01:29:03.944]                 args <- list()
[01:29:03.944]                 for (kk in seq_along(NAMES)) {
[01:29:03.944]                   name <- changed[[kk]]
[01:29:03.944]                   NAME <- NAMES[[kk]]
[01:29:03.944]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:03.944]                     next
[01:29:03.944]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:03.944]                 }
[01:29:03.944]                 NAMES <- toupper(added)
[01:29:03.944]                 for (kk in seq_along(NAMES)) {
[01:29:03.944]                   name <- added[[kk]]
[01:29:03.944]                   NAME <- NAMES[[kk]]
[01:29:03.944]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:03.944]                     next
[01:29:03.944]                   args[[name]] <- ""
[01:29:03.944]                 }
[01:29:03.944]                 NAMES <- toupper(removed)
[01:29:03.944]                 for (kk in seq_along(NAMES)) {
[01:29:03.944]                   name <- removed[[kk]]
[01:29:03.944]                   NAME <- NAMES[[kk]]
[01:29:03.944]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:03.944]                     next
[01:29:03.944]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:03.944]                 }
[01:29:03.944]                 if (length(args) > 0) 
[01:29:03.944]                   base::do.call(base::Sys.setenv, args = args)
[01:29:03.944]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:03.944]             }
[01:29:03.944]             else {
[01:29:03.944]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:03.944]             }
[01:29:03.944]             {
[01:29:03.944]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:03.944]                   0L) {
[01:29:03.944]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:03.944]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:03.944]                   base::options(opts)
[01:29:03.944]                 }
[01:29:03.944]                 {
[01:29:03.944]                   {
[01:29:03.944]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:03.944]                     NULL
[01:29:03.944]                   }
[01:29:03.944]                   options(future.plan = NULL)
[01:29:03.944]                   if (is.na(NA_character_)) 
[01:29:03.944]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:03.944]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:03.944]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:03.944]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:03.944]                     envir = parent.frame()) 
[01:29:03.944]                   {
[01:29:03.944]                     if (is.function(workers)) 
[01:29:03.944]                       workers <- workers()
[01:29:03.944]                     workers <- structure(as.integer(workers), 
[01:29:03.944]                       class = class(workers))
[01:29:03.944]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:03.944]                       workers >= 1)
[01:29:03.944]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:03.944]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:03.944]                     }
[01:29:03.944]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:03.944]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:03.944]                       envir = envir)
[01:29:03.944]                     if (!future$lazy) 
[01:29:03.944]                       future <- run(future)
[01:29:03.944]                     invisible(future)
[01:29:03.944]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:03.944]                 }
[01:29:03.944]             }
[01:29:03.944]         }
[01:29:03.944]     })
[01:29:03.944]     if (TRUE) {
[01:29:03.944]         base::sink(type = "output", split = FALSE)
[01:29:03.944]         if (TRUE) {
[01:29:03.944]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:03.944]         }
[01:29:03.944]         else {
[01:29:03.944]             ...future.result["stdout"] <- base::list(NULL)
[01:29:03.944]         }
[01:29:03.944]         base::close(...future.stdout)
[01:29:03.944]         ...future.stdout <- NULL
[01:29:03.944]     }
[01:29:03.944]     ...future.result$conditions <- ...future.conditions
[01:29:03.944]     ...future.result$finished <- base::Sys.time()
[01:29:03.944]     ...future.result
[01:29:03.944] }
[01:29:03.950] MultisessionFuture started
[01:29:03.950] - Launch lazy future ... done
[01:29:03.950] run() for 'MultisessionFuture' ... done
[01:29:04.473] receiveMessageFromWorker() for ClusterFuture ...
[01:29:04.474] - Validating connection of MultisessionFuture
[01:29:04.474] - received message: FutureResult
[01:29:04.474] - Received FutureResult
[01:29:04.475] - Erased future from FutureRegistry
[01:29:04.475] result() for ClusterFuture ...
[01:29:04.475] - result already collected: FutureResult
[01:29:04.475] result() for ClusterFuture ... done
[01:29:04.475] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:04.476] A MultisessionFuture was resolved
[01:29:04.476] getGlobalsAndPackages() ...
[01:29:04.476] Searching for globals...
[01:29:04.478] - globals found: [3] '{', 'Sys.sleep', 'list'
[01:29:04.478] Searching for globals ... DONE
[01:29:04.478] Resolving globals: FALSE
[01:29:04.478] 
[01:29:04.479] 
[01:29:04.479] getGlobalsAndPackages() ... DONE
[01:29:04.479] run() for 'Future' ...
[01:29:04.479] - state: 'created'
[01:29:04.480] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:04.494] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:04.495] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:04.495]   - Field: 'node'
[01:29:04.495]   - Field: 'label'
[01:29:04.495]   - Field: 'local'
[01:29:04.495]   - Field: 'owner'
[01:29:04.496]   - Field: 'envir'
[01:29:04.496]   - Field: 'workers'
[01:29:04.496]   - Field: 'packages'
[01:29:04.496]   - Field: 'gc'
[01:29:04.496]   - Field: 'conditions'
[01:29:04.496]   - Field: 'persistent'
[01:29:04.497]   - Field: 'expr'
[01:29:04.497]   - Field: 'uuid'
[01:29:04.497]   - Field: 'seed'
[01:29:04.497]   - Field: 'version'
[01:29:04.497]   - Field: 'result'
[01:29:04.498]   - Field: 'asynchronous'
[01:29:04.498]   - Field: 'calls'
[01:29:04.498]   - Field: 'globals'
[01:29:04.498]   - Field: 'stdout'
[01:29:04.498]   - Field: 'earlySignal'
[01:29:04.498]   - Field: 'lazy'
[01:29:04.499]   - Field: 'state'
[01:29:04.499] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:04.499] - Launch lazy future ...
[01:29:04.499] Packages needed by the future expression (n = 0): <none>
[01:29:04.500] Packages needed by future strategies (n = 0): <none>
[01:29:04.500] {
[01:29:04.500]     {
[01:29:04.500]         {
[01:29:04.500]             ...future.startTime <- base::Sys.time()
[01:29:04.500]             {
[01:29:04.500]                 {
[01:29:04.500]                   {
[01:29:04.500]                     {
[01:29:04.500]                       base::local({
[01:29:04.500]                         has_future <- base::requireNamespace("future", 
[01:29:04.500]                           quietly = TRUE)
[01:29:04.500]                         if (has_future) {
[01:29:04.500]                           ns <- base::getNamespace("future")
[01:29:04.500]                           version <- ns[[".package"]][["version"]]
[01:29:04.500]                           if (is.null(version)) 
[01:29:04.500]                             version <- utils::packageVersion("future")
[01:29:04.500]                         }
[01:29:04.500]                         else {
[01:29:04.500]                           version <- NULL
[01:29:04.500]                         }
[01:29:04.500]                         if (!has_future || version < "1.8.0") {
[01:29:04.500]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:04.500]                             "", base::R.version$version.string), 
[01:29:04.500]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:04.500]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:04.500]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:04.500]                               "release", "version")], collapse = " "), 
[01:29:04.500]                             hostname = base::Sys.info()[["nodename"]])
[01:29:04.500]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:04.500]                             info)
[01:29:04.500]                           info <- base::paste(info, collapse = "; ")
[01:29:04.500]                           if (!has_future) {
[01:29:04.500]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:04.500]                               info)
[01:29:04.500]                           }
[01:29:04.500]                           else {
[01:29:04.500]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:04.500]                               info, version)
[01:29:04.500]                           }
[01:29:04.500]                           base::stop(msg)
[01:29:04.500]                         }
[01:29:04.500]                       })
[01:29:04.500]                     }
[01:29:04.500]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:04.500]                     base::options(mc.cores = 1L)
[01:29:04.500]                   }
[01:29:04.500]                   options(future.plan = NULL)
[01:29:04.500]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:04.500]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:04.500]                 }
[01:29:04.500]                 ...future.workdir <- getwd()
[01:29:04.500]             }
[01:29:04.500]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:04.500]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:04.500]         }
[01:29:04.500]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:04.500]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:04.500]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:04.500]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:04.500]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:04.500]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:04.500]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:04.500]             base::names(...future.oldOptions))
[01:29:04.500]     }
[01:29:04.500]     if (FALSE) {
[01:29:04.500]     }
[01:29:04.500]     else {
[01:29:04.500]         if (TRUE) {
[01:29:04.500]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:04.500]                 open = "w")
[01:29:04.500]         }
[01:29:04.500]         else {
[01:29:04.500]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:04.500]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:04.500]         }
[01:29:04.500]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:04.500]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:04.500]             base::sink(type = "output", split = FALSE)
[01:29:04.500]             base::close(...future.stdout)
[01:29:04.500]         }, add = TRUE)
[01:29:04.500]     }
[01:29:04.500]     ...future.frame <- base::sys.nframe()
[01:29:04.500]     ...future.conditions <- base::list()
[01:29:04.500]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:04.500]     if (FALSE) {
[01:29:04.500]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:04.500]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:04.500]     }
[01:29:04.500]     ...future.result <- base::tryCatch({
[01:29:04.500]         base::withCallingHandlers({
[01:29:04.500]             ...future.value <- base::withVisible(base::local({
[01:29:04.500]                 ...future.makeSendCondition <- base::local({
[01:29:04.500]                   sendCondition <- NULL
[01:29:04.500]                   function(frame = 1L) {
[01:29:04.500]                     if (is.function(sendCondition)) 
[01:29:04.500]                       return(sendCondition)
[01:29:04.500]                     ns <- getNamespace("parallel")
[01:29:04.500]                     if (exists("sendData", mode = "function", 
[01:29:04.500]                       envir = ns)) {
[01:29:04.500]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:04.500]                         envir = ns)
[01:29:04.500]                       envir <- sys.frame(frame)
[01:29:04.500]                       master <- NULL
[01:29:04.500]                       while (!identical(envir, .GlobalEnv) && 
[01:29:04.500]                         !identical(envir, emptyenv())) {
[01:29:04.500]                         if (exists("master", mode = "list", envir = envir, 
[01:29:04.500]                           inherits = FALSE)) {
[01:29:04.500]                           master <- get("master", mode = "list", 
[01:29:04.500]                             envir = envir, inherits = FALSE)
[01:29:04.500]                           if (inherits(master, c("SOCKnode", 
[01:29:04.500]                             "SOCK0node"))) {
[01:29:04.500]                             sendCondition <<- function(cond) {
[01:29:04.500]                               data <- list(type = "VALUE", value = cond, 
[01:29:04.500]                                 success = TRUE)
[01:29:04.500]                               parallel_sendData(master, data)
[01:29:04.500]                             }
[01:29:04.500]                             return(sendCondition)
[01:29:04.500]                           }
[01:29:04.500]                         }
[01:29:04.500]                         frame <- frame + 1L
[01:29:04.500]                         envir <- sys.frame(frame)
[01:29:04.500]                       }
[01:29:04.500]                     }
[01:29:04.500]                     sendCondition <<- function(cond) NULL
[01:29:04.500]                   }
[01:29:04.500]                 })
[01:29:04.500]                 withCallingHandlers({
[01:29:04.500]                   {
[01:29:04.500]                     Sys.sleep(0.5)
[01:29:04.500]                     list(a = 1, b = 42L)
[01:29:04.500]                   }
[01:29:04.500]                 }, immediateCondition = function(cond) {
[01:29:04.500]                   sendCondition <- ...future.makeSendCondition()
[01:29:04.500]                   sendCondition(cond)
[01:29:04.500]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:04.500]                   {
[01:29:04.500]                     inherits <- base::inherits
[01:29:04.500]                     invokeRestart <- base::invokeRestart
[01:29:04.500]                     is.null <- base::is.null
[01:29:04.500]                     muffled <- FALSE
[01:29:04.500]                     if (inherits(cond, "message")) {
[01:29:04.500]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:04.500]                       if (muffled) 
[01:29:04.500]                         invokeRestart("muffleMessage")
[01:29:04.500]                     }
[01:29:04.500]                     else if (inherits(cond, "warning")) {
[01:29:04.500]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:04.500]                       if (muffled) 
[01:29:04.500]                         invokeRestart("muffleWarning")
[01:29:04.500]                     }
[01:29:04.500]                     else if (inherits(cond, "condition")) {
[01:29:04.500]                       if (!is.null(pattern)) {
[01:29:04.500]                         computeRestarts <- base::computeRestarts
[01:29:04.500]                         grepl <- base::grepl
[01:29:04.500]                         restarts <- computeRestarts(cond)
[01:29:04.500]                         for (restart in restarts) {
[01:29:04.500]                           name <- restart$name
[01:29:04.500]                           if (is.null(name)) 
[01:29:04.500]                             next
[01:29:04.500]                           if (!grepl(pattern, name)) 
[01:29:04.500]                             next
[01:29:04.500]                           invokeRestart(restart)
[01:29:04.500]                           muffled <- TRUE
[01:29:04.500]                           break
[01:29:04.500]                         }
[01:29:04.500]                       }
[01:29:04.500]                     }
[01:29:04.500]                     invisible(muffled)
[01:29:04.500]                   }
[01:29:04.500]                   muffleCondition(cond)
[01:29:04.500]                 })
[01:29:04.500]             }))
[01:29:04.500]             future::FutureResult(value = ...future.value$value, 
[01:29:04.500]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:04.500]                   ...future.rng), globalenv = if (FALSE) 
[01:29:04.500]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:04.500]                     ...future.globalenv.names))
[01:29:04.500]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:04.500]         }, condition = base::local({
[01:29:04.500]             c <- base::c
[01:29:04.500]             inherits <- base::inherits
[01:29:04.500]             invokeRestart <- base::invokeRestart
[01:29:04.500]             length <- base::length
[01:29:04.500]             list <- base::list
[01:29:04.500]             seq.int <- base::seq.int
[01:29:04.500]             signalCondition <- base::signalCondition
[01:29:04.500]             sys.calls <- base::sys.calls
[01:29:04.500]             `[[` <- base::`[[`
[01:29:04.500]             `+` <- base::`+`
[01:29:04.500]             `<<-` <- base::`<<-`
[01:29:04.500]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:04.500]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:04.500]                   3L)]
[01:29:04.500]             }
[01:29:04.500]             function(cond) {
[01:29:04.500]                 is_error <- inherits(cond, "error")
[01:29:04.500]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:04.500]                   NULL)
[01:29:04.500]                 if (is_error) {
[01:29:04.500]                   sessionInformation <- function() {
[01:29:04.500]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:04.500]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:04.500]                       search = base::search(), system = base::Sys.info())
[01:29:04.500]                   }
[01:29:04.500]                   ...future.conditions[[length(...future.conditions) + 
[01:29:04.500]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:04.500]                     cond$call), session = sessionInformation(), 
[01:29:04.500]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:04.500]                   signalCondition(cond)
[01:29:04.500]                 }
[01:29:04.500]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:04.500]                 "immediateCondition"))) {
[01:29:04.500]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:04.500]                   ...future.conditions[[length(...future.conditions) + 
[01:29:04.500]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:04.500]                   if (TRUE && !signal) {
[01:29:04.500]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:04.500]                     {
[01:29:04.500]                       inherits <- base::inherits
[01:29:04.500]                       invokeRestart <- base::invokeRestart
[01:29:04.500]                       is.null <- base::is.null
[01:29:04.500]                       muffled <- FALSE
[01:29:04.500]                       if (inherits(cond, "message")) {
[01:29:04.500]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:04.500]                         if (muffled) 
[01:29:04.500]                           invokeRestart("muffleMessage")
[01:29:04.500]                       }
[01:29:04.500]                       else if (inherits(cond, "warning")) {
[01:29:04.500]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:04.500]                         if (muffled) 
[01:29:04.500]                           invokeRestart("muffleWarning")
[01:29:04.500]                       }
[01:29:04.500]                       else if (inherits(cond, "condition")) {
[01:29:04.500]                         if (!is.null(pattern)) {
[01:29:04.500]                           computeRestarts <- base::computeRestarts
[01:29:04.500]                           grepl <- base::grepl
[01:29:04.500]                           restarts <- computeRestarts(cond)
[01:29:04.500]                           for (restart in restarts) {
[01:29:04.500]                             name <- restart$name
[01:29:04.500]                             if (is.null(name)) 
[01:29:04.500]                               next
[01:29:04.500]                             if (!grepl(pattern, name)) 
[01:29:04.500]                               next
[01:29:04.500]                             invokeRestart(restart)
[01:29:04.500]                             muffled <- TRUE
[01:29:04.500]                             break
[01:29:04.500]                           }
[01:29:04.500]                         }
[01:29:04.500]                       }
[01:29:04.500]                       invisible(muffled)
[01:29:04.500]                     }
[01:29:04.500]                     muffleCondition(cond, pattern = "^muffle")
[01:29:04.500]                   }
[01:29:04.500]                 }
[01:29:04.500]                 else {
[01:29:04.500]                   if (TRUE) {
[01:29:04.500]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:04.500]                     {
[01:29:04.500]                       inherits <- base::inherits
[01:29:04.500]                       invokeRestart <- base::invokeRestart
[01:29:04.500]                       is.null <- base::is.null
[01:29:04.500]                       muffled <- FALSE
[01:29:04.500]                       if (inherits(cond, "message")) {
[01:29:04.500]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:04.500]                         if (muffled) 
[01:29:04.500]                           invokeRestart("muffleMessage")
[01:29:04.500]                       }
[01:29:04.500]                       else if (inherits(cond, "warning")) {
[01:29:04.500]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:04.500]                         if (muffled) 
[01:29:04.500]                           invokeRestart("muffleWarning")
[01:29:04.500]                       }
[01:29:04.500]                       else if (inherits(cond, "condition")) {
[01:29:04.500]                         if (!is.null(pattern)) {
[01:29:04.500]                           computeRestarts <- base::computeRestarts
[01:29:04.500]                           grepl <- base::grepl
[01:29:04.500]                           restarts <- computeRestarts(cond)
[01:29:04.500]                           for (restart in restarts) {
[01:29:04.500]                             name <- restart$name
[01:29:04.500]                             if (is.null(name)) 
[01:29:04.500]                               next
[01:29:04.500]                             if (!grepl(pattern, name)) 
[01:29:04.500]                               next
[01:29:04.500]                             invokeRestart(restart)
[01:29:04.500]                             muffled <- TRUE
[01:29:04.500]                             break
[01:29:04.500]                           }
[01:29:04.500]                         }
[01:29:04.500]                       }
[01:29:04.500]                       invisible(muffled)
[01:29:04.500]                     }
[01:29:04.500]                     muffleCondition(cond, pattern = "^muffle")
[01:29:04.500]                   }
[01:29:04.500]                 }
[01:29:04.500]             }
[01:29:04.500]         }))
[01:29:04.500]     }, error = function(ex) {
[01:29:04.500]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:04.500]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:04.500]                 ...future.rng), started = ...future.startTime, 
[01:29:04.500]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:04.500]             version = "1.8"), class = "FutureResult")
[01:29:04.500]     }, finally = {
[01:29:04.500]         if (!identical(...future.workdir, getwd())) 
[01:29:04.500]             setwd(...future.workdir)
[01:29:04.500]         {
[01:29:04.500]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:04.500]                 ...future.oldOptions$nwarnings <- NULL
[01:29:04.500]             }
[01:29:04.500]             base::options(...future.oldOptions)
[01:29:04.500]             if (.Platform$OS.type == "windows") {
[01:29:04.500]                 old_names <- names(...future.oldEnvVars)
[01:29:04.500]                 envs <- base::Sys.getenv()
[01:29:04.500]                 names <- names(envs)
[01:29:04.500]                 common <- intersect(names, old_names)
[01:29:04.500]                 added <- setdiff(names, old_names)
[01:29:04.500]                 removed <- setdiff(old_names, names)
[01:29:04.500]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:04.500]                   envs[common]]
[01:29:04.500]                 NAMES <- toupper(changed)
[01:29:04.500]                 args <- list()
[01:29:04.500]                 for (kk in seq_along(NAMES)) {
[01:29:04.500]                   name <- changed[[kk]]
[01:29:04.500]                   NAME <- NAMES[[kk]]
[01:29:04.500]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:04.500]                     next
[01:29:04.500]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:04.500]                 }
[01:29:04.500]                 NAMES <- toupper(added)
[01:29:04.500]                 for (kk in seq_along(NAMES)) {
[01:29:04.500]                   name <- added[[kk]]
[01:29:04.500]                   NAME <- NAMES[[kk]]
[01:29:04.500]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:04.500]                     next
[01:29:04.500]                   args[[name]] <- ""
[01:29:04.500]                 }
[01:29:04.500]                 NAMES <- toupper(removed)
[01:29:04.500]                 for (kk in seq_along(NAMES)) {
[01:29:04.500]                   name <- removed[[kk]]
[01:29:04.500]                   NAME <- NAMES[[kk]]
[01:29:04.500]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:04.500]                     next
[01:29:04.500]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:04.500]                 }
[01:29:04.500]                 if (length(args) > 0) 
[01:29:04.500]                   base::do.call(base::Sys.setenv, args = args)
[01:29:04.500]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:04.500]             }
[01:29:04.500]             else {
[01:29:04.500]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:04.500]             }
[01:29:04.500]             {
[01:29:04.500]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:04.500]                   0L) {
[01:29:04.500]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:04.500]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:04.500]                   base::options(opts)
[01:29:04.500]                 }
[01:29:04.500]                 {
[01:29:04.500]                   {
[01:29:04.500]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:04.500]                     NULL
[01:29:04.500]                   }
[01:29:04.500]                   options(future.plan = NULL)
[01:29:04.500]                   if (is.na(NA_character_)) 
[01:29:04.500]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:04.500]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:04.500]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:04.500]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:04.500]                     envir = parent.frame()) 
[01:29:04.500]                   {
[01:29:04.500]                     if (is.function(workers)) 
[01:29:04.500]                       workers <- workers()
[01:29:04.500]                     workers <- structure(as.integer(workers), 
[01:29:04.500]                       class = class(workers))
[01:29:04.500]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:04.500]                       workers >= 1)
[01:29:04.500]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:04.500]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:04.500]                     }
[01:29:04.500]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:04.500]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:04.500]                       envir = envir)
[01:29:04.500]                     if (!future$lazy) 
[01:29:04.500]                       future <- run(future)
[01:29:04.500]                     invisible(future)
[01:29:04.500]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:04.500]                 }
[01:29:04.500]             }
[01:29:04.500]         }
[01:29:04.500]     })
[01:29:04.500]     if (TRUE) {
[01:29:04.500]         base::sink(type = "output", split = FALSE)
[01:29:04.500]         if (TRUE) {
[01:29:04.500]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:04.500]         }
[01:29:04.500]         else {
[01:29:04.500]             ...future.result["stdout"] <- base::list(NULL)
[01:29:04.500]         }
[01:29:04.500]         base::close(...future.stdout)
[01:29:04.500]         ...future.stdout <- NULL
[01:29:04.500]     }
[01:29:04.500]     ...future.result$conditions <- ...future.conditions
[01:29:04.500]     ...future.result$finished <- base::Sys.time()
[01:29:04.500]     ...future.result
[01:29:04.500] }
[01:29:04.507] MultisessionFuture started
[01:29:04.507] - Launch lazy future ... done
[01:29:04.507] run() for 'MultisessionFuture' ... done
[01:29:05.033] receiveMessageFromWorker() for ClusterFuture ...
[01:29:05.034] - Validating connection of MultisessionFuture
[01:29:05.034] - received message: FutureResult
[01:29:05.034] - Received FutureResult
[01:29:05.035] - Erased future from FutureRegistry
[01:29:05.035] result() for ClusterFuture ...
[01:29:05.035] - result already collected: FutureResult
[01:29:05.035] result() for ClusterFuture ... done
[01:29:05.035] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:05.036] A MultisessionFuture was resolved
- w/ exception ...
[01:29:05.036] getGlobalsAndPackages() ...
[01:29:05.036] Searching for globals...
[01:29:05.037] - globals found: [2] 'list', 'stop'
[01:29:05.037] Searching for globals ... DONE
[01:29:05.037] Resolving globals: FALSE
[01:29:05.038] 
[01:29:05.038] 
[01:29:05.038] getGlobalsAndPackages() ... DONE
[01:29:05.039] run() for 'Future' ...
[01:29:05.039] - state: 'created'
[01:29:05.039] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:05.054] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:05.054] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:05.054]   - Field: 'node'
[01:29:05.054]   - Field: 'label'
[01:29:05.055]   - Field: 'local'
[01:29:05.055]   - Field: 'owner'
[01:29:05.055]   - Field: 'envir'
[01:29:05.055]   - Field: 'workers'
[01:29:05.055]   - Field: 'packages'
[01:29:05.055]   - Field: 'gc'
[01:29:05.056]   - Field: 'conditions'
[01:29:05.056]   - Field: 'persistent'
[01:29:05.056]   - Field: 'expr'
[01:29:05.056]   - Field: 'uuid'
[01:29:05.056]   - Field: 'seed'
[01:29:05.057]   - Field: 'version'
[01:29:05.057]   - Field: 'result'
[01:29:05.057]   - Field: 'asynchronous'
[01:29:05.057]   - Field: 'calls'
[01:29:05.057]   - Field: 'globals'
[01:29:05.058]   - Field: 'stdout'
[01:29:05.058]   - Field: 'earlySignal'
[01:29:05.058]   - Field: 'lazy'
[01:29:05.058]   - Field: 'state'
[01:29:05.058] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:05.059] - Launch lazy future ...
[01:29:05.059] Packages needed by the future expression (n = 0): <none>
[01:29:05.059] Packages needed by future strategies (n = 0): <none>
[01:29:05.060] {
[01:29:05.060]     {
[01:29:05.060]         {
[01:29:05.060]             ...future.startTime <- base::Sys.time()
[01:29:05.060]             {
[01:29:05.060]                 {
[01:29:05.060]                   {
[01:29:05.060]                     {
[01:29:05.060]                       base::local({
[01:29:05.060]                         has_future <- base::requireNamespace("future", 
[01:29:05.060]                           quietly = TRUE)
[01:29:05.060]                         if (has_future) {
[01:29:05.060]                           ns <- base::getNamespace("future")
[01:29:05.060]                           version <- ns[[".package"]][["version"]]
[01:29:05.060]                           if (is.null(version)) 
[01:29:05.060]                             version <- utils::packageVersion("future")
[01:29:05.060]                         }
[01:29:05.060]                         else {
[01:29:05.060]                           version <- NULL
[01:29:05.060]                         }
[01:29:05.060]                         if (!has_future || version < "1.8.0") {
[01:29:05.060]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:05.060]                             "", base::R.version$version.string), 
[01:29:05.060]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:05.060]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:05.060]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:05.060]                               "release", "version")], collapse = " "), 
[01:29:05.060]                             hostname = base::Sys.info()[["nodename"]])
[01:29:05.060]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:05.060]                             info)
[01:29:05.060]                           info <- base::paste(info, collapse = "; ")
[01:29:05.060]                           if (!has_future) {
[01:29:05.060]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:05.060]                               info)
[01:29:05.060]                           }
[01:29:05.060]                           else {
[01:29:05.060]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:05.060]                               info, version)
[01:29:05.060]                           }
[01:29:05.060]                           base::stop(msg)
[01:29:05.060]                         }
[01:29:05.060]                       })
[01:29:05.060]                     }
[01:29:05.060]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:05.060]                     base::options(mc.cores = 1L)
[01:29:05.060]                   }
[01:29:05.060]                   options(future.plan = NULL)
[01:29:05.060]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:05.060]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:05.060]                 }
[01:29:05.060]                 ...future.workdir <- getwd()
[01:29:05.060]             }
[01:29:05.060]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:05.060]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:05.060]         }
[01:29:05.060]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:05.060]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:05.060]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:05.060]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:05.060]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:05.060]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:05.060]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:05.060]             base::names(...future.oldOptions))
[01:29:05.060]     }
[01:29:05.060]     if (FALSE) {
[01:29:05.060]     }
[01:29:05.060]     else {
[01:29:05.060]         if (TRUE) {
[01:29:05.060]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:05.060]                 open = "w")
[01:29:05.060]         }
[01:29:05.060]         else {
[01:29:05.060]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:05.060]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:05.060]         }
[01:29:05.060]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:05.060]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:05.060]             base::sink(type = "output", split = FALSE)
[01:29:05.060]             base::close(...future.stdout)
[01:29:05.060]         }, add = TRUE)
[01:29:05.060]     }
[01:29:05.060]     ...future.frame <- base::sys.nframe()
[01:29:05.060]     ...future.conditions <- base::list()
[01:29:05.060]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:05.060]     if (FALSE) {
[01:29:05.060]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:05.060]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:05.060]     }
[01:29:05.060]     ...future.result <- base::tryCatch({
[01:29:05.060]         base::withCallingHandlers({
[01:29:05.060]             ...future.value <- base::withVisible(base::local({
[01:29:05.060]                 ...future.makeSendCondition <- base::local({
[01:29:05.060]                   sendCondition <- NULL
[01:29:05.060]                   function(frame = 1L) {
[01:29:05.060]                     if (is.function(sendCondition)) 
[01:29:05.060]                       return(sendCondition)
[01:29:05.060]                     ns <- getNamespace("parallel")
[01:29:05.060]                     if (exists("sendData", mode = "function", 
[01:29:05.060]                       envir = ns)) {
[01:29:05.060]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:05.060]                         envir = ns)
[01:29:05.060]                       envir <- sys.frame(frame)
[01:29:05.060]                       master <- NULL
[01:29:05.060]                       while (!identical(envir, .GlobalEnv) && 
[01:29:05.060]                         !identical(envir, emptyenv())) {
[01:29:05.060]                         if (exists("master", mode = "list", envir = envir, 
[01:29:05.060]                           inherits = FALSE)) {
[01:29:05.060]                           master <- get("master", mode = "list", 
[01:29:05.060]                             envir = envir, inherits = FALSE)
[01:29:05.060]                           if (inherits(master, c("SOCKnode", 
[01:29:05.060]                             "SOCK0node"))) {
[01:29:05.060]                             sendCondition <<- function(cond) {
[01:29:05.060]                               data <- list(type = "VALUE", value = cond, 
[01:29:05.060]                                 success = TRUE)
[01:29:05.060]                               parallel_sendData(master, data)
[01:29:05.060]                             }
[01:29:05.060]                             return(sendCondition)
[01:29:05.060]                           }
[01:29:05.060]                         }
[01:29:05.060]                         frame <- frame + 1L
[01:29:05.060]                         envir <- sys.frame(frame)
[01:29:05.060]                       }
[01:29:05.060]                     }
[01:29:05.060]                     sendCondition <<- function(cond) NULL
[01:29:05.060]                   }
[01:29:05.060]                 })
[01:29:05.060]                 withCallingHandlers({
[01:29:05.060]                   list(a = 1, b = 42L, c = stop("Nah!"))
[01:29:05.060]                 }, immediateCondition = function(cond) {
[01:29:05.060]                   sendCondition <- ...future.makeSendCondition()
[01:29:05.060]                   sendCondition(cond)
[01:29:05.060]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:05.060]                   {
[01:29:05.060]                     inherits <- base::inherits
[01:29:05.060]                     invokeRestart <- base::invokeRestart
[01:29:05.060]                     is.null <- base::is.null
[01:29:05.060]                     muffled <- FALSE
[01:29:05.060]                     if (inherits(cond, "message")) {
[01:29:05.060]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:05.060]                       if (muffled) 
[01:29:05.060]                         invokeRestart("muffleMessage")
[01:29:05.060]                     }
[01:29:05.060]                     else if (inherits(cond, "warning")) {
[01:29:05.060]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:05.060]                       if (muffled) 
[01:29:05.060]                         invokeRestart("muffleWarning")
[01:29:05.060]                     }
[01:29:05.060]                     else if (inherits(cond, "condition")) {
[01:29:05.060]                       if (!is.null(pattern)) {
[01:29:05.060]                         computeRestarts <- base::computeRestarts
[01:29:05.060]                         grepl <- base::grepl
[01:29:05.060]                         restarts <- computeRestarts(cond)
[01:29:05.060]                         for (restart in restarts) {
[01:29:05.060]                           name <- restart$name
[01:29:05.060]                           if (is.null(name)) 
[01:29:05.060]                             next
[01:29:05.060]                           if (!grepl(pattern, name)) 
[01:29:05.060]                             next
[01:29:05.060]                           invokeRestart(restart)
[01:29:05.060]                           muffled <- TRUE
[01:29:05.060]                           break
[01:29:05.060]                         }
[01:29:05.060]                       }
[01:29:05.060]                     }
[01:29:05.060]                     invisible(muffled)
[01:29:05.060]                   }
[01:29:05.060]                   muffleCondition(cond)
[01:29:05.060]                 })
[01:29:05.060]             }))
[01:29:05.060]             future::FutureResult(value = ...future.value$value, 
[01:29:05.060]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:05.060]                   ...future.rng), globalenv = if (FALSE) 
[01:29:05.060]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:05.060]                     ...future.globalenv.names))
[01:29:05.060]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:05.060]         }, condition = base::local({
[01:29:05.060]             c <- base::c
[01:29:05.060]             inherits <- base::inherits
[01:29:05.060]             invokeRestart <- base::invokeRestart
[01:29:05.060]             length <- base::length
[01:29:05.060]             list <- base::list
[01:29:05.060]             seq.int <- base::seq.int
[01:29:05.060]             signalCondition <- base::signalCondition
[01:29:05.060]             sys.calls <- base::sys.calls
[01:29:05.060]             `[[` <- base::`[[`
[01:29:05.060]             `+` <- base::`+`
[01:29:05.060]             `<<-` <- base::`<<-`
[01:29:05.060]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:05.060]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:05.060]                   3L)]
[01:29:05.060]             }
[01:29:05.060]             function(cond) {
[01:29:05.060]                 is_error <- inherits(cond, "error")
[01:29:05.060]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:05.060]                   NULL)
[01:29:05.060]                 if (is_error) {
[01:29:05.060]                   sessionInformation <- function() {
[01:29:05.060]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:05.060]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:05.060]                       search = base::search(), system = base::Sys.info())
[01:29:05.060]                   }
[01:29:05.060]                   ...future.conditions[[length(...future.conditions) + 
[01:29:05.060]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:05.060]                     cond$call), session = sessionInformation(), 
[01:29:05.060]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:05.060]                   signalCondition(cond)
[01:29:05.060]                 }
[01:29:05.060]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:05.060]                 "immediateCondition"))) {
[01:29:05.060]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:05.060]                   ...future.conditions[[length(...future.conditions) + 
[01:29:05.060]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:05.060]                   if (TRUE && !signal) {
[01:29:05.060]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:05.060]                     {
[01:29:05.060]                       inherits <- base::inherits
[01:29:05.060]                       invokeRestart <- base::invokeRestart
[01:29:05.060]                       is.null <- base::is.null
[01:29:05.060]                       muffled <- FALSE
[01:29:05.060]                       if (inherits(cond, "message")) {
[01:29:05.060]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:05.060]                         if (muffled) 
[01:29:05.060]                           invokeRestart("muffleMessage")
[01:29:05.060]                       }
[01:29:05.060]                       else if (inherits(cond, "warning")) {
[01:29:05.060]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:05.060]                         if (muffled) 
[01:29:05.060]                           invokeRestart("muffleWarning")
[01:29:05.060]                       }
[01:29:05.060]                       else if (inherits(cond, "condition")) {
[01:29:05.060]                         if (!is.null(pattern)) {
[01:29:05.060]                           computeRestarts <- base::computeRestarts
[01:29:05.060]                           grepl <- base::grepl
[01:29:05.060]                           restarts <- computeRestarts(cond)
[01:29:05.060]                           for (restart in restarts) {
[01:29:05.060]                             name <- restart$name
[01:29:05.060]                             if (is.null(name)) 
[01:29:05.060]                               next
[01:29:05.060]                             if (!grepl(pattern, name)) 
[01:29:05.060]                               next
[01:29:05.060]                             invokeRestart(restart)
[01:29:05.060]                             muffled <- TRUE
[01:29:05.060]                             break
[01:29:05.060]                           }
[01:29:05.060]                         }
[01:29:05.060]                       }
[01:29:05.060]                       invisible(muffled)
[01:29:05.060]                     }
[01:29:05.060]                     muffleCondition(cond, pattern = "^muffle")
[01:29:05.060]                   }
[01:29:05.060]                 }
[01:29:05.060]                 else {
[01:29:05.060]                   if (TRUE) {
[01:29:05.060]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:05.060]                     {
[01:29:05.060]                       inherits <- base::inherits
[01:29:05.060]                       invokeRestart <- base::invokeRestart
[01:29:05.060]                       is.null <- base::is.null
[01:29:05.060]                       muffled <- FALSE
[01:29:05.060]                       if (inherits(cond, "message")) {
[01:29:05.060]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:05.060]                         if (muffled) 
[01:29:05.060]                           invokeRestart("muffleMessage")
[01:29:05.060]                       }
[01:29:05.060]                       else if (inherits(cond, "warning")) {
[01:29:05.060]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:05.060]                         if (muffled) 
[01:29:05.060]                           invokeRestart("muffleWarning")
[01:29:05.060]                       }
[01:29:05.060]                       else if (inherits(cond, "condition")) {
[01:29:05.060]                         if (!is.null(pattern)) {
[01:29:05.060]                           computeRestarts <- base::computeRestarts
[01:29:05.060]                           grepl <- base::grepl
[01:29:05.060]                           restarts <- computeRestarts(cond)
[01:29:05.060]                           for (restart in restarts) {
[01:29:05.060]                             name <- restart$name
[01:29:05.060]                             if (is.null(name)) 
[01:29:05.060]                               next
[01:29:05.060]                             if (!grepl(pattern, name)) 
[01:29:05.060]                               next
[01:29:05.060]                             invokeRestart(restart)
[01:29:05.060]                             muffled <- TRUE
[01:29:05.060]                             break
[01:29:05.060]                           }
[01:29:05.060]                         }
[01:29:05.060]                       }
[01:29:05.060]                       invisible(muffled)
[01:29:05.060]                     }
[01:29:05.060]                     muffleCondition(cond, pattern = "^muffle")
[01:29:05.060]                   }
[01:29:05.060]                 }
[01:29:05.060]             }
[01:29:05.060]         }))
[01:29:05.060]     }, error = function(ex) {
[01:29:05.060]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:05.060]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:05.060]                 ...future.rng), started = ...future.startTime, 
[01:29:05.060]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:05.060]             version = "1.8"), class = "FutureResult")
[01:29:05.060]     }, finally = {
[01:29:05.060]         if (!identical(...future.workdir, getwd())) 
[01:29:05.060]             setwd(...future.workdir)
[01:29:05.060]         {
[01:29:05.060]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:05.060]                 ...future.oldOptions$nwarnings <- NULL
[01:29:05.060]             }
[01:29:05.060]             base::options(...future.oldOptions)
[01:29:05.060]             if (.Platform$OS.type == "windows") {
[01:29:05.060]                 old_names <- names(...future.oldEnvVars)
[01:29:05.060]                 envs <- base::Sys.getenv()
[01:29:05.060]                 names <- names(envs)
[01:29:05.060]                 common <- intersect(names, old_names)
[01:29:05.060]                 added <- setdiff(names, old_names)
[01:29:05.060]                 removed <- setdiff(old_names, names)
[01:29:05.060]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:05.060]                   envs[common]]
[01:29:05.060]                 NAMES <- toupper(changed)
[01:29:05.060]                 args <- list()
[01:29:05.060]                 for (kk in seq_along(NAMES)) {
[01:29:05.060]                   name <- changed[[kk]]
[01:29:05.060]                   NAME <- NAMES[[kk]]
[01:29:05.060]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:05.060]                     next
[01:29:05.060]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:05.060]                 }
[01:29:05.060]                 NAMES <- toupper(added)
[01:29:05.060]                 for (kk in seq_along(NAMES)) {
[01:29:05.060]                   name <- added[[kk]]
[01:29:05.060]                   NAME <- NAMES[[kk]]
[01:29:05.060]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:05.060]                     next
[01:29:05.060]                   args[[name]] <- ""
[01:29:05.060]                 }
[01:29:05.060]                 NAMES <- toupper(removed)
[01:29:05.060]                 for (kk in seq_along(NAMES)) {
[01:29:05.060]                   name <- removed[[kk]]
[01:29:05.060]                   NAME <- NAMES[[kk]]
[01:29:05.060]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:05.060]                     next
[01:29:05.060]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:05.060]                 }
[01:29:05.060]                 if (length(args) > 0) 
[01:29:05.060]                   base::do.call(base::Sys.setenv, args = args)
[01:29:05.060]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:05.060]             }
[01:29:05.060]             else {
[01:29:05.060]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:05.060]             }
[01:29:05.060]             {
[01:29:05.060]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:05.060]                   0L) {
[01:29:05.060]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:05.060]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:05.060]                   base::options(opts)
[01:29:05.060]                 }
[01:29:05.060]                 {
[01:29:05.060]                   {
[01:29:05.060]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:05.060]                     NULL
[01:29:05.060]                   }
[01:29:05.060]                   options(future.plan = NULL)
[01:29:05.060]                   if (is.na(NA_character_)) 
[01:29:05.060]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:05.060]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:05.060]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:05.060]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:05.060]                     envir = parent.frame()) 
[01:29:05.060]                   {
[01:29:05.060]                     if (is.function(workers)) 
[01:29:05.060]                       workers <- workers()
[01:29:05.060]                     workers <- structure(as.integer(workers), 
[01:29:05.060]                       class = class(workers))
[01:29:05.060]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:05.060]                       workers >= 1)
[01:29:05.060]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:05.060]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:05.060]                     }
[01:29:05.060]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:05.060]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:05.060]                       envir = envir)
[01:29:05.060]                     if (!future$lazy) 
[01:29:05.060]                       future <- run(future)
[01:29:05.060]                     invisible(future)
[01:29:05.060]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:05.060]                 }
[01:29:05.060]             }
[01:29:05.060]         }
[01:29:05.060]     })
[01:29:05.060]     if (TRUE) {
[01:29:05.060]         base::sink(type = "output", split = FALSE)
[01:29:05.060]         if (TRUE) {
[01:29:05.060]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:05.060]         }
[01:29:05.060]         else {
[01:29:05.060]             ...future.result["stdout"] <- base::list(NULL)
[01:29:05.060]         }
[01:29:05.060]         base::close(...future.stdout)
[01:29:05.060]         ...future.stdout <- NULL
[01:29:05.060]     }
[01:29:05.060]     ...future.result$conditions <- ...future.conditions
[01:29:05.060]     ...future.result$finished <- base::Sys.time()
[01:29:05.060]     ...future.result
[01:29:05.060] }
[01:29:05.069] MultisessionFuture started
[01:29:05.069] - Launch lazy future ... done
[01:29:05.070] run() for 'MultisessionFuture' ... done
[01:29:05.087] receiveMessageFromWorker() for ClusterFuture ...
[01:29:05.087] - Validating connection of MultisessionFuture
[01:29:05.087] - received message: FutureResult
[01:29:05.087] - Received FutureResult
[01:29:05.088] - Erased future from FutureRegistry
[01:29:05.088] result() for ClusterFuture ...
[01:29:05.088] - result already collected: FutureResult
[01:29:05.088] result() for ClusterFuture ... done
[01:29:05.088] signalConditions() ...
[01:29:05.088]  - include = 'immediateCondition'
[01:29:05.089]  - exclude = 
[01:29:05.089]  - resignal = FALSE
[01:29:05.089]  - Number of conditions: 1
[01:29:05.089] signalConditions() ... done
[01:29:05.089] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:05.089] A MultisessionFuture was resolved
[01:29:05.090] getGlobalsAndPackages() ...
[01:29:05.090] Searching for globals...
[01:29:05.091] - globals found: [2] 'list', 'stop'
[01:29:05.091] Searching for globals ... DONE
[01:29:05.091] Resolving globals: FALSE
[01:29:05.092] 
[01:29:05.092] 
[01:29:05.092] getGlobalsAndPackages() ... DONE
[01:29:05.092] run() for 'Future' ...
[01:29:05.093] - state: 'created'
[01:29:05.093] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:05.107] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:05.107] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:05.107]   - Field: 'node'
[01:29:05.108]   - Field: 'label'
[01:29:05.108]   - Field: 'local'
[01:29:05.108]   - Field: 'owner'
[01:29:05.108]   - Field: 'envir'
[01:29:05.108]   - Field: 'workers'
[01:29:05.108]   - Field: 'packages'
[01:29:05.109]   - Field: 'gc'
[01:29:05.109]   - Field: 'conditions'
[01:29:05.109]   - Field: 'persistent'
[01:29:05.109]   - Field: 'expr'
[01:29:05.109]   - Field: 'uuid'
[01:29:05.110]   - Field: 'seed'
[01:29:05.110]   - Field: 'version'
[01:29:05.110]   - Field: 'result'
[01:29:05.110]   - Field: 'asynchronous'
[01:29:05.110]   - Field: 'calls'
[01:29:05.110]   - Field: 'globals'
[01:29:05.111]   - Field: 'stdout'
[01:29:05.111]   - Field: 'earlySignal'
[01:29:05.111]   - Field: 'lazy'
[01:29:05.111]   - Field: 'state'
[01:29:05.111] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:05.112] - Launch lazy future ...
[01:29:05.112] Packages needed by the future expression (n = 0): <none>
[01:29:05.112] Packages needed by future strategies (n = 0): <none>
[01:29:05.113] {
[01:29:05.113]     {
[01:29:05.113]         {
[01:29:05.113]             ...future.startTime <- base::Sys.time()
[01:29:05.113]             {
[01:29:05.113]                 {
[01:29:05.113]                   {
[01:29:05.113]                     {
[01:29:05.113]                       base::local({
[01:29:05.113]                         has_future <- base::requireNamespace("future", 
[01:29:05.113]                           quietly = TRUE)
[01:29:05.113]                         if (has_future) {
[01:29:05.113]                           ns <- base::getNamespace("future")
[01:29:05.113]                           version <- ns[[".package"]][["version"]]
[01:29:05.113]                           if (is.null(version)) 
[01:29:05.113]                             version <- utils::packageVersion("future")
[01:29:05.113]                         }
[01:29:05.113]                         else {
[01:29:05.113]                           version <- NULL
[01:29:05.113]                         }
[01:29:05.113]                         if (!has_future || version < "1.8.0") {
[01:29:05.113]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:05.113]                             "", base::R.version$version.string), 
[01:29:05.113]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:05.113]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:05.113]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:05.113]                               "release", "version")], collapse = " "), 
[01:29:05.113]                             hostname = base::Sys.info()[["nodename"]])
[01:29:05.113]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:05.113]                             info)
[01:29:05.113]                           info <- base::paste(info, collapse = "; ")
[01:29:05.113]                           if (!has_future) {
[01:29:05.113]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:05.113]                               info)
[01:29:05.113]                           }
[01:29:05.113]                           else {
[01:29:05.113]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:05.113]                               info, version)
[01:29:05.113]                           }
[01:29:05.113]                           base::stop(msg)
[01:29:05.113]                         }
[01:29:05.113]                       })
[01:29:05.113]                     }
[01:29:05.113]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:05.113]                     base::options(mc.cores = 1L)
[01:29:05.113]                   }
[01:29:05.113]                   options(future.plan = NULL)
[01:29:05.113]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:05.113]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:05.113]                 }
[01:29:05.113]                 ...future.workdir <- getwd()
[01:29:05.113]             }
[01:29:05.113]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:05.113]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:05.113]         }
[01:29:05.113]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:05.113]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:05.113]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:05.113]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:05.113]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:05.113]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:05.113]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:05.113]             base::names(...future.oldOptions))
[01:29:05.113]     }
[01:29:05.113]     if (FALSE) {
[01:29:05.113]     }
[01:29:05.113]     else {
[01:29:05.113]         if (TRUE) {
[01:29:05.113]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:05.113]                 open = "w")
[01:29:05.113]         }
[01:29:05.113]         else {
[01:29:05.113]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:05.113]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:05.113]         }
[01:29:05.113]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:05.113]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:05.113]             base::sink(type = "output", split = FALSE)
[01:29:05.113]             base::close(...future.stdout)
[01:29:05.113]         }, add = TRUE)
[01:29:05.113]     }
[01:29:05.113]     ...future.frame <- base::sys.nframe()
[01:29:05.113]     ...future.conditions <- base::list()
[01:29:05.113]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:05.113]     if (FALSE) {
[01:29:05.113]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:05.113]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:05.113]     }
[01:29:05.113]     ...future.result <- base::tryCatch({
[01:29:05.113]         base::withCallingHandlers({
[01:29:05.113]             ...future.value <- base::withVisible(base::local({
[01:29:05.113]                 ...future.makeSendCondition <- base::local({
[01:29:05.113]                   sendCondition <- NULL
[01:29:05.113]                   function(frame = 1L) {
[01:29:05.113]                     if (is.function(sendCondition)) 
[01:29:05.113]                       return(sendCondition)
[01:29:05.113]                     ns <- getNamespace("parallel")
[01:29:05.113]                     if (exists("sendData", mode = "function", 
[01:29:05.113]                       envir = ns)) {
[01:29:05.113]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:05.113]                         envir = ns)
[01:29:05.113]                       envir <- sys.frame(frame)
[01:29:05.113]                       master <- NULL
[01:29:05.113]                       while (!identical(envir, .GlobalEnv) && 
[01:29:05.113]                         !identical(envir, emptyenv())) {
[01:29:05.113]                         if (exists("master", mode = "list", envir = envir, 
[01:29:05.113]                           inherits = FALSE)) {
[01:29:05.113]                           master <- get("master", mode = "list", 
[01:29:05.113]                             envir = envir, inherits = FALSE)
[01:29:05.113]                           if (inherits(master, c("SOCKnode", 
[01:29:05.113]                             "SOCK0node"))) {
[01:29:05.113]                             sendCondition <<- function(cond) {
[01:29:05.113]                               data <- list(type = "VALUE", value = cond, 
[01:29:05.113]                                 success = TRUE)
[01:29:05.113]                               parallel_sendData(master, data)
[01:29:05.113]                             }
[01:29:05.113]                             return(sendCondition)
[01:29:05.113]                           }
[01:29:05.113]                         }
[01:29:05.113]                         frame <- frame + 1L
[01:29:05.113]                         envir <- sys.frame(frame)
[01:29:05.113]                       }
[01:29:05.113]                     }
[01:29:05.113]                     sendCondition <<- function(cond) NULL
[01:29:05.113]                   }
[01:29:05.113]                 })
[01:29:05.113]                 withCallingHandlers({
[01:29:05.113]                   list(a = 1, b = 42L, c = stop("Nah!"))
[01:29:05.113]                 }, immediateCondition = function(cond) {
[01:29:05.113]                   sendCondition <- ...future.makeSendCondition()
[01:29:05.113]                   sendCondition(cond)
[01:29:05.113]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:05.113]                   {
[01:29:05.113]                     inherits <- base::inherits
[01:29:05.113]                     invokeRestart <- base::invokeRestart
[01:29:05.113]                     is.null <- base::is.null
[01:29:05.113]                     muffled <- FALSE
[01:29:05.113]                     if (inherits(cond, "message")) {
[01:29:05.113]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:05.113]                       if (muffled) 
[01:29:05.113]                         invokeRestart("muffleMessage")
[01:29:05.113]                     }
[01:29:05.113]                     else if (inherits(cond, "warning")) {
[01:29:05.113]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:05.113]                       if (muffled) 
[01:29:05.113]                         invokeRestart("muffleWarning")
[01:29:05.113]                     }
[01:29:05.113]                     else if (inherits(cond, "condition")) {
[01:29:05.113]                       if (!is.null(pattern)) {
[01:29:05.113]                         computeRestarts <- base::computeRestarts
[01:29:05.113]                         grepl <- base::grepl
[01:29:05.113]                         restarts <- computeRestarts(cond)
[01:29:05.113]                         for (restart in restarts) {
[01:29:05.113]                           name <- restart$name
[01:29:05.113]                           if (is.null(name)) 
[01:29:05.113]                             next
[01:29:05.113]                           if (!grepl(pattern, name)) 
[01:29:05.113]                             next
[01:29:05.113]                           invokeRestart(restart)
[01:29:05.113]                           muffled <- TRUE
[01:29:05.113]                           break
[01:29:05.113]                         }
[01:29:05.113]                       }
[01:29:05.113]                     }
[01:29:05.113]                     invisible(muffled)
[01:29:05.113]                   }
[01:29:05.113]                   muffleCondition(cond)
[01:29:05.113]                 })
[01:29:05.113]             }))
[01:29:05.113]             future::FutureResult(value = ...future.value$value, 
[01:29:05.113]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:05.113]                   ...future.rng), globalenv = if (FALSE) 
[01:29:05.113]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:05.113]                     ...future.globalenv.names))
[01:29:05.113]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:05.113]         }, condition = base::local({
[01:29:05.113]             c <- base::c
[01:29:05.113]             inherits <- base::inherits
[01:29:05.113]             invokeRestart <- base::invokeRestart
[01:29:05.113]             length <- base::length
[01:29:05.113]             list <- base::list
[01:29:05.113]             seq.int <- base::seq.int
[01:29:05.113]             signalCondition <- base::signalCondition
[01:29:05.113]             sys.calls <- base::sys.calls
[01:29:05.113]             `[[` <- base::`[[`
[01:29:05.113]             `+` <- base::`+`
[01:29:05.113]             `<<-` <- base::`<<-`
[01:29:05.113]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:05.113]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:05.113]                   3L)]
[01:29:05.113]             }
[01:29:05.113]             function(cond) {
[01:29:05.113]                 is_error <- inherits(cond, "error")
[01:29:05.113]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:05.113]                   NULL)
[01:29:05.113]                 if (is_error) {
[01:29:05.113]                   sessionInformation <- function() {
[01:29:05.113]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:05.113]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:05.113]                       search = base::search(), system = base::Sys.info())
[01:29:05.113]                   }
[01:29:05.113]                   ...future.conditions[[length(...future.conditions) + 
[01:29:05.113]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:05.113]                     cond$call), session = sessionInformation(), 
[01:29:05.113]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:05.113]                   signalCondition(cond)
[01:29:05.113]                 }
[01:29:05.113]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:05.113]                 "immediateCondition"))) {
[01:29:05.113]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:05.113]                   ...future.conditions[[length(...future.conditions) + 
[01:29:05.113]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:05.113]                   if (TRUE && !signal) {
[01:29:05.113]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:05.113]                     {
[01:29:05.113]                       inherits <- base::inherits
[01:29:05.113]                       invokeRestart <- base::invokeRestart
[01:29:05.113]                       is.null <- base::is.null
[01:29:05.113]                       muffled <- FALSE
[01:29:05.113]                       if (inherits(cond, "message")) {
[01:29:05.113]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:05.113]                         if (muffled) 
[01:29:05.113]                           invokeRestart("muffleMessage")
[01:29:05.113]                       }
[01:29:05.113]                       else if (inherits(cond, "warning")) {
[01:29:05.113]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:05.113]                         if (muffled) 
[01:29:05.113]                           invokeRestart("muffleWarning")
[01:29:05.113]                       }
[01:29:05.113]                       else if (inherits(cond, "condition")) {
[01:29:05.113]                         if (!is.null(pattern)) {
[01:29:05.113]                           computeRestarts <- base::computeRestarts
[01:29:05.113]                           grepl <- base::grepl
[01:29:05.113]                           restarts <- computeRestarts(cond)
[01:29:05.113]                           for (restart in restarts) {
[01:29:05.113]                             name <- restart$name
[01:29:05.113]                             if (is.null(name)) 
[01:29:05.113]                               next
[01:29:05.113]                             if (!grepl(pattern, name)) 
[01:29:05.113]                               next
[01:29:05.113]                             invokeRestart(restart)
[01:29:05.113]                             muffled <- TRUE
[01:29:05.113]                             break
[01:29:05.113]                           }
[01:29:05.113]                         }
[01:29:05.113]                       }
[01:29:05.113]                       invisible(muffled)
[01:29:05.113]                     }
[01:29:05.113]                     muffleCondition(cond, pattern = "^muffle")
[01:29:05.113]                   }
[01:29:05.113]                 }
[01:29:05.113]                 else {
[01:29:05.113]                   if (TRUE) {
[01:29:05.113]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:05.113]                     {
[01:29:05.113]                       inherits <- base::inherits
[01:29:05.113]                       invokeRestart <- base::invokeRestart
[01:29:05.113]                       is.null <- base::is.null
[01:29:05.113]                       muffled <- FALSE
[01:29:05.113]                       if (inherits(cond, "message")) {
[01:29:05.113]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:05.113]                         if (muffled) 
[01:29:05.113]                           invokeRestart("muffleMessage")
[01:29:05.113]                       }
[01:29:05.113]                       else if (inherits(cond, "warning")) {
[01:29:05.113]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:05.113]                         if (muffled) 
[01:29:05.113]                           invokeRestart("muffleWarning")
[01:29:05.113]                       }
[01:29:05.113]                       else if (inherits(cond, "condition")) {
[01:29:05.113]                         if (!is.null(pattern)) {
[01:29:05.113]                           computeRestarts <- base::computeRestarts
[01:29:05.113]                           grepl <- base::grepl
[01:29:05.113]                           restarts <- computeRestarts(cond)
[01:29:05.113]                           for (restart in restarts) {
[01:29:05.113]                             name <- restart$name
[01:29:05.113]                             if (is.null(name)) 
[01:29:05.113]                               next
[01:29:05.113]                             if (!grepl(pattern, name)) 
[01:29:05.113]                               next
[01:29:05.113]                             invokeRestart(restart)
[01:29:05.113]                             muffled <- TRUE
[01:29:05.113]                             break
[01:29:05.113]                           }
[01:29:05.113]                         }
[01:29:05.113]                       }
[01:29:05.113]                       invisible(muffled)
[01:29:05.113]                     }
[01:29:05.113]                     muffleCondition(cond, pattern = "^muffle")
[01:29:05.113]                   }
[01:29:05.113]                 }
[01:29:05.113]             }
[01:29:05.113]         }))
[01:29:05.113]     }, error = function(ex) {
[01:29:05.113]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:05.113]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:05.113]                 ...future.rng), started = ...future.startTime, 
[01:29:05.113]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:05.113]             version = "1.8"), class = "FutureResult")
[01:29:05.113]     }, finally = {
[01:29:05.113]         if (!identical(...future.workdir, getwd())) 
[01:29:05.113]             setwd(...future.workdir)
[01:29:05.113]         {
[01:29:05.113]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:05.113]                 ...future.oldOptions$nwarnings <- NULL
[01:29:05.113]             }
[01:29:05.113]             base::options(...future.oldOptions)
[01:29:05.113]             if (.Platform$OS.type == "windows") {
[01:29:05.113]                 old_names <- names(...future.oldEnvVars)
[01:29:05.113]                 envs <- base::Sys.getenv()
[01:29:05.113]                 names <- names(envs)
[01:29:05.113]                 common <- intersect(names, old_names)
[01:29:05.113]                 added <- setdiff(names, old_names)
[01:29:05.113]                 removed <- setdiff(old_names, names)
[01:29:05.113]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:05.113]                   envs[common]]
[01:29:05.113]                 NAMES <- toupper(changed)
[01:29:05.113]                 args <- list()
[01:29:05.113]                 for (kk in seq_along(NAMES)) {
[01:29:05.113]                   name <- changed[[kk]]
[01:29:05.113]                   NAME <- NAMES[[kk]]
[01:29:05.113]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:05.113]                     next
[01:29:05.113]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:05.113]                 }
[01:29:05.113]                 NAMES <- toupper(added)
[01:29:05.113]                 for (kk in seq_along(NAMES)) {
[01:29:05.113]                   name <- added[[kk]]
[01:29:05.113]                   NAME <- NAMES[[kk]]
[01:29:05.113]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:05.113]                     next
[01:29:05.113]                   args[[name]] <- ""
[01:29:05.113]                 }
[01:29:05.113]                 NAMES <- toupper(removed)
[01:29:05.113]                 for (kk in seq_along(NAMES)) {
[01:29:05.113]                   name <- removed[[kk]]
[01:29:05.113]                   NAME <- NAMES[[kk]]
[01:29:05.113]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:05.113]                     next
[01:29:05.113]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:05.113]                 }
[01:29:05.113]                 if (length(args) > 0) 
[01:29:05.113]                   base::do.call(base::Sys.setenv, args = args)
[01:29:05.113]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:05.113]             }
[01:29:05.113]             else {
[01:29:05.113]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:05.113]             }
[01:29:05.113]             {
[01:29:05.113]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:05.113]                   0L) {
[01:29:05.113]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:05.113]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:05.113]                   base::options(opts)
[01:29:05.113]                 }
[01:29:05.113]                 {
[01:29:05.113]                   {
[01:29:05.113]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:05.113]                     NULL
[01:29:05.113]                   }
[01:29:05.113]                   options(future.plan = NULL)
[01:29:05.113]                   if (is.na(NA_character_)) 
[01:29:05.113]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:05.113]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:05.113]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:05.113]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:05.113]                     envir = parent.frame()) 
[01:29:05.113]                   {
[01:29:05.113]                     if (is.function(workers)) 
[01:29:05.113]                       workers <- workers()
[01:29:05.113]                     workers <- structure(as.integer(workers), 
[01:29:05.113]                       class = class(workers))
[01:29:05.113]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:05.113]                       workers >= 1)
[01:29:05.113]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:05.113]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:05.113]                     }
[01:29:05.113]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:05.113]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:05.113]                       envir = envir)
[01:29:05.113]                     if (!future$lazy) 
[01:29:05.113]                       future <- run(future)
[01:29:05.113]                     invisible(future)
[01:29:05.113]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:05.113]                 }
[01:29:05.113]             }
[01:29:05.113]         }
[01:29:05.113]     })
[01:29:05.113]     if (TRUE) {
[01:29:05.113]         base::sink(type = "output", split = FALSE)
[01:29:05.113]         if (TRUE) {
[01:29:05.113]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:05.113]         }
[01:29:05.113]         else {
[01:29:05.113]             ...future.result["stdout"] <- base::list(NULL)
[01:29:05.113]         }
[01:29:05.113]         base::close(...future.stdout)
[01:29:05.113]         ...future.stdout <- NULL
[01:29:05.113]     }
[01:29:05.113]     ...future.result$conditions <- ...future.conditions
[01:29:05.113]     ...future.result$finished <- base::Sys.time()
[01:29:05.113]     ...future.result
[01:29:05.113] }
[01:29:05.118] MultisessionFuture started
[01:29:05.119] - Launch lazy future ... done
[01:29:05.119] run() for 'MultisessionFuture' ... done
[01:29:05.136] receiveMessageFromWorker() for ClusterFuture ...
[01:29:05.137] - Validating connection of MultisessionFuture
[01:29:05.137] - received message: FutureResult
[01:29:05.137] - Received FutureResult
[01:29:05.137] - Erased future from FutureRegistry
[01:29:05.138] result() for ClusterFuture ...
[01:29:05.138] - result already collected: FutureResult
[01:29:05.138] result() for ClusterFuture ... done
[01:29:05.138] signalConditions() ...
[01:29:05.138]  - include = 'immediateCondition'
[01:29:05.138]  - exclude = 
[01:29:05.139]  - resignal = FALSE
[01:29:05.139]  - Number of conditions: 1
[01:29:05.139] signalConditions() ... done
[01:29:05.139] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:05.139] A MultisessionFuture was resolved
- result = TRUE, recursive = FALSE ... DONE
- result = TRUE, recursive = TRUE ...
[01:29:05.140] getGlobalsAndPackages() ...
[01:29:05.140] Searching for globals...
[01:29:05.141] - globals found: [3] '{', 'Sys.sleep', 'list'
[01:29:05.141] Searching for globals ... DONE
[01:29:05.142] Resolving globals: FALSE
[01:29:05.142] 
[01:29:05.142] 
[01:29:05.142] getGlobalsAndPackages() ... DONE
[01:29:05.143] run() for 'Future' ...
[01:29:05.143] - state: 'created'
[01:29:05.143] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:05.157] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:05.157] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:05.158]   - Field: 'node'
[01:29:05.158]   - Field: 'label'
[01:29:05.158]   - Field: 'local'
[01:29:05.158]   - Field: 'owner'
[01:29:05.158]   - Field: 'envir'
[01:29:05.159]   - Field: 'workers'
[01:29:05.159]   - Field: 'packages'
[01:29:05.159]   - Field: 'gc'
[01:29:05.159]   - Field: 'conditions'
[01:29:05.159]   - Field: 'persistent'
[01:29:05.159]   - Field: 'expr'
[01:29:05.160]   - Field: 'uuid'
[01:29:05.160]   - Field: 'seed'
[01:29:05.160]   - Field: 'version'
[01:29:05.160]   - Field: 'result'
[01:29:05.160]   - Field: 'asynchronous'
[01:29:05.161]   - Field: 'calls'
[01:29:05.161]   - Field: 'globals'
[01:29:05.161]   - Field: 'stdout'
[01:29:05.161]   - Field: 'earlySignal'
[01:29:05.161]   - Field: 'lazy'
[01:29:05.161]   - Field: 'state'
[01:29:05.162] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:05.162] - Launch lazy future ...
[01:29:05.162] Packages needed by the future expression (n = 0): <none>
[01:29:05.162] Packages needed by future strategies (n = 0): <none>
[01:29:05.163] {
[01:29:05.163]     {
[01:29:05.163]         {
[01:29:05.163]             ...future.startTime <- base::Sys.time()
[01:29:05.163]             {
[01:29:05.163]                 {
[01:29:05.163]                   {
[01:29:05.163]                     {
[01:29:05.163]                       base::local({
[01:29:05.163]                         has_future <- base::requireNamespace("future", 
[01:29:05.163]                           quietly = TRUE)
[01:29:05.163]                         if (has_future) {
[01:29:05.163]                           ns <- base::getNamespace("future")
[01:29:05.163]                           version <- ns[[".package"]][["version"]]
[01:29:05.163]                           if (is.null(version)) 
[01:29:05.163]                             version <- utils::packageVersion("future")
[01:29:05.163]                         }
[01:29:05.163]                         else {
[01:29:05.163]                           version <- NULL
[01:29:05.163]                         }
[01:29:05.163]                         if (!has_future || version < "1.8.0") {
[01:29:05.163]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:05.163]                             "", base::R.version$version.string), 
[01:29:05.163]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:05.163]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:05.163]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:05.163]                               "release", "version")], collapse = " "), 
[01:29:05.163]                             hostname = base::Sys.info()[["nodename"]])
[01:29:05.163]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:05.163]                             info)
[01:29:05.163]                           info <- base::paste(info, collapse = "; ")
[01:29:05.163]                           if (!has_future) {
[01:29:05.163]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:05.163]                               info)
[01:29:05.163]                           }
[01:29:05.163]                           else {
[01:29:05.163]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:05.163]                               info, version)
[01:29:05.163]                           }
[01:29:05.163]                           base::stop(msg)
[01:29:05.163]                         }
[01:29:05.163]                       })
[01:29:05.163]                     }
[01:29:05.163]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:05.163]                     base::options(mc.cores = 1L)
[01:29:05.163]                   }
[01:29:05.163]                   options(future.plan = NULL)
[01:29:05.163]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:05.163]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:05.163]                 }
[01:29:05.163]                 ...future.workdir <- getwd()
[01:29:05.163]             }
[01:29:05.163]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:05.163]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:05.163]         }
[01:29:05.163]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:05.163]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:05.163]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:05.163]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:05.163]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:05.163]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:05.163]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:05.163]             base::names(...future.oldOptions))
[01:29:05.163]     }
[01:29:05.163]     if (FALSE) {
[01:29:05.163]     }
[01:29:05.163]     else {
[01:29:05.163]         if (TRUE) {
[01:29:05.163]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:05.163]                 open = "w")
[01:29:05.163]         }
[01:29:05.163]         else {
[01:29:05.163]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:05.163]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:05.163]         }
[01:29:05.163]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:05.163]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:05.163]             base::sink(type = "output", split = FALSE)
[01:29:05.163]             base::close(...future.stdout)
[01:29:05.163]         }, add = TRUE)
[01:29:05.163]     }
[01:29:05.163]     ...future.frame <- base::sys.nframe()
[01:29:05.163]     ...future.conditions <- base::list()
[01:29:05.163]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:05.163]     if (FALSE) {
[01:29:05.163]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:05.163]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:05.163]     }
[01:29:05.163]     ...future.result <- base::tryCatch({
[01:29:05.163]         base::withCallingHandlers({
[01:29:05.163]             ...future.value <- base::withVisible(base::local({
[01:29:05.163]                 ...future.makeSendCondition <- base::local({
[01:29:05.163]                   sendCondition <- NULL
[01:29:05.163]                   function(frame = 1L) {
[01:29:05.163]                     if (is.function(sendCondition)) 
[01:29:05.163]                       return(sendCondition)
[01:29:05.163]                     ns <- getNamespace("parallel")
[01:29:05.163]                     if (exists("sendData", mode = "function", 
[01:29:05.163]                       envir = ns)) {
[01:29:05.163]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:05.163]                         envir = ns)
[01:29:05.163]                       envir <- sys.frame(frame)
[01:29:05.163]                       master <- NULL
[01:29:05.163]                       while (!identical(envir, .GlobalEnv) && 
[01:29:05.163]                         !identical(envir, emptyenv())) {
[01:29:05.163]                         if (exists("master", mode = "list", envir = envir, 
[01:29:05.163]                           inherits = FALSE)) {
[01:29:05.163]                           master <- get("master", mode = "list", 
[01:29:05.163]                             envir = envir, inherits = FALSE)
[01:29:05.163]                           if (inherits(master, c("SOCKnode", 
[01:29:05.163]                             "SOCK0node"))) {
[01:29:05.163]                             sendCondition <<- function(cond) {
[01:29:05.163]                               data <- list(type = "VALUE", value = cond, 
[01:29:05.163]                                 success = TRUE)
[01:29:05.163]                               parallel_sendData(master, data)
[01:29:05.163]                             }
[01:29:05.163]                             return(sendCondition)
[01:29:05.163]                           }
[01:29:05.163]                         }
[01:29:05.163]                         frame <- frame + 1L
[01:29:05.163]                         envir <- sys.frame(frame)
[01:29:05.163]                       }
[01:29:05.163]                     }
[01:29:05.163]                     sendCondition <<- function(cond) NULL
[01:29:05.163]                   }
[01:29:05.163]                 })
[01:29:05.163]                 withCallingHandlers({
[01:29:05.163]                   {
[01:29:05.163]                     Sys.sleep(0.5)
[01:29:05.163]                     list(a = 1, b = 42L)
[01:29:05.163]                   }
[01:29:05.163]                 }, immediateCondition = function(cond) {
[01:29:05.163]                   sendCondition <- ...future.makeSendCondition()
[01:29:05.163]                   sendCondition(cond)
[01:29:05.163]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:05.163]                   {
[01:29:05.163]                     inherits <- base::inherits
[01:29:05.163]                     invokeRestart <- base::invokeRestart
[01:29:05.163]                     is.null <- base::is.null
[01:29:05.163]                     muffled <- FALSE
[01:29:05.163]                     if (inherits(cond, "message")) {
[01:29:05.163]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:05.163]                       if (muffled) 
[01:29:05.163]                         invokeRestart("muffleMessage")
[01:29:05.163]                     }
[01:29:05.163]                     else if (inherits(cond, "warning")) {
[01:29:05.163]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:05.163]                       if (muffled) 
[01:29:05.163]                         invokeRestart("muffleWarning")
[01:29:05.163]                     }
[01:29:05.163]                     else if (inherits(cond, "condition")) {
[01:29:05.163]                       if (!is.null(pattern)) {
[01:29:05.163]                         computeRestarts <- base::computeRestarts
[01:29:05.163]                         grepl <- base::grepl
[01:29:05.163]                         restarts <- computeRestarts(cond)
[01:29:05.163]                         for (restart in restarts) {
[01:29:05.163]                           name <- restart$name
[01:29:05.163]                           if (is.null(name)) 
[01:29:05.163]                             next
[01:29:05.163]                           if (!grepl(pattern, name)) 
[01:29:05.163]                             next
[01:29:05.163]                           invokeRestart(restart)
[01:29:05.163]                           muffled <- TRUE
[01:29:05.163]                           break
[01:29:05.163]                         }
[01:29:05.163]                       }
[01:29:05.163]                     }
[01:29:05.163]                     invisible(muffled)
[01:29:05.163]                   }
[01:29:05.163]                   muffleCondition(cond)
[01:29:05.163]                 })
[01:29:05.163]             }))
[01:29:05.163]             future::FutureResult(value = ...future.value$value, 
[01:29:05.163]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:05.163]                   ...future.rng), globalenv = if (FALSE) 
[01:29:05.163]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:05.163]                     ...future.globalenv.names))
[01:29:05.163]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:05.163]         }, condition = base::local({
[01:29:05.163]             c <- base::c
[01:29:05.163]             inherits <- base::inherits
[01:29:05.163]             invokeRestart <- base::invokeRestart
[01:29:05.163]             length <- base::length
[01:29:05.163]             list <- base::list
[01:29:05.163]             seq.int <- base::seq.int
[01:29:05.163]             signalCondition <- base::signalCondition
[01:29:05.163]             sys.calls <- base::sys.calls
[01:29:05.163]             `[[` <- base::`[[`
[01:29:05.163]             `+` <- base::`+`
[01:29:05.163]             `<<-` <- base::`<<-`
[01:29:05.163]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:05.163]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:05.163]                   3L)]
[01:29:05.163]             }
[01:29:05.163]             function(cond) {
[01:29:05.163]                 is_error <- inherits(cond, "error")
[01:29:05.163]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:05.163]                   NULL)
[01:29:05.163]                 if (is_error) {
[01:29:05.163]                   sessionInformation <- function() {
[01:29:05.163]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:05.163]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:05.163]                       search = base::search(), system = base::Sys.info())
[01:29:05.163]                   }
[01:29:05.163]                   ...future.conditions[[length(...future.conditions) + 
[01:29:05.163]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:05.163]                     cond$call), session = sessionInformation(), 
[01:29:05.163]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:05.163]                   signalCondition(cond)
[01:29:05.163]                 }
[01:29:05.163]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:05.163]                 "immediateCondition"))) {
[01:29:05.163]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:05.163]                   ...future.conditions[[length(...future.conditions) + 
[01:29:05.163]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:05.163]                   if (TRUE && !signal) {
[01:29:05.163]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:05.163]                     {
[01:29:05.163]                       inherits <- base::inherits
[01:29:05.163]                       invokeRestart <- base::invokeRestart
[01:29:05.163]                       is.null <- base::is.null
[01:29:05.163]                       muffled <- FALSE
[01:29:05.163]                       if (inherits(cond, "message")) {
[01:29:05.163]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:05.163]                         if (muffled) 
[01:29:05.163]                           invokeRestart("muffleMessage")
[01:29:05.163]                       }
[01:29:05.163]                       else if (inherits(cond, "warning")) {
[01:29:05.163]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:05.163]                         if (muffled) 
[01:29:05.163]                           invokeRestart("muffleWarning")
[01:29:05.163]                       }
[01:29:05.163]                       else if (inherits(cond, "condition")) {
[01:29:05.163]                         if (!is.null(pattern)) {
[01:29:05.163]                           computeRestarts <- base::computeRestarts
[01:29:05.163]                           grepl <- base::grepl
[01:29:05.163]                           restarts <- computeRestarts(cond)
[01:29:05.163]                           for (restart in restarts) {
[01:29:05.163]                             name <- restart$name
[01:29:05.163]                             if (is.null(name)) 
[01:29:05.163]                               next
[01:29:05.163]                             if (!grepl(pattern, name)) 
[01:29:05.163]                               next
[01:29:05.163]                             invokeRestart(restart)
[01:29:05.163]                             muffled <- TRUE
[01:29:05.163]                             break
[01:29:05.163]                           }
[01:29:05.163]                         }
[01:29:05.163]                       }
[01:29:05.163]                       invisible(muffled)
[01:29:05.163]                     }
[01:29:05.163]                     muffleCondition(cond, pattern = "^muffle")
[01:29:05.163]                   }
[01:29:05.163]                 }
[01:29:05.163]                 else {
[01:29:05.163]                   if (TRUE) {
[01:29:05.163]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:05.163]                     {
[01:29:05.163]                       inherits <- base::inherits
[01:29:05.163]                       invokeRestart <- base::invokeRestart
[01:29:05.163]                       is.null <- base::is.null
[01:29:05.163]                       muffled <- FALSE
[01:29:05.163]                       if (inherits(cond, "message")) {
[01:29:05.163]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:05.163]                         if (muffled) 
[01:29:05.163]                           invokeRestart("muffleMessage")
[01:29:05.163]                       }
[01:29:05.163]                       else if (inherits(cond, "warning")) {
[01:29:05.163]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:05.163]                         if (muffled) 
[01:29:05.163]                           invokeRestart("muffleWarning")
[01:29:05.163]                       }
[01:29:05.163]                       else if (inherits(cond, "condition")) {
[01:29:05.163]                         if (!is.null(pattern)) {
[01:29:05.163]                           computeRestarts <- base::computeRestarts
[01:29:05.163]                           grepl <- base::grepl
[01:29:05.163]                           restarts <- computeRestarts(cond)
[01:29:05.163]                           for (restart in restarts) {
[01:29:05.163]                             name <- restart$name
[01:29:05.163]                             if (is.null(name)) 
[01:29:05.163]                               next
[01:29:05.163]                             if (!grepl(pattern, name)) 
[01:29:05.163]                               next
[01:29:05.163]                             invokeRestart(restart)
[01:29:05.163]                             muffled <- TRUE
[01:29:05.163]                             break
[01:29:05.163]                           }
[01:29:05.163]                         }
[01:29:05.163]                       }
[01:29:05.163]                       invisible(muffled)
[01:29:05.163]                     }
[01:29:05.163]                     muffleCondition(cond, pattern = "^muffle")
[01:29:05.163]                   }
[01:29:05.163]                 }
[01:29:05.163]             }
[01:29:05.163]         }))
[01:29:05.163]     }, error = function(ex) {
[01:29:05.163]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:05.163]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:05.163]                 ...future.rng), started = ...future.startTime, 
[01:29:05.163]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:05.163]             version = "1.8"), class = "FutureResult")
[01:29:05.163]     }, finally = {
[01:29:05.163]         if (!identical(...future.workdir, getwd())) 
[01:29:05.163]             setwd(...future.workdir)
[01:29:05.163]         {
[01:29:05.163]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:05.163]                 ...future.oldOptions$nwarnings <- NULL
[01:29:05.163]             }
[01:29:05.163]             base::options(...future.oldOptions)
[01:29:05.163]             if (.Platform$OS.type == "windows") {
[01:29:05.163]                 old_names <- names(...future.oldEnvVars)
[01:29:05.163]                 envs <- base::Sys.getenv()
[01:29:05.163]                 names <- names(envs)
[01:29:05.163]                 common <- intersect(names, old_names)
[01:29:05.163]                 added <- setdiff(names, old_names)
[01:29:05.163]                 removed <- setdiff(old_names, names)
[01:29:05.163]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:05.163]                   envs[common]]
[01:29:05.163]                 NAMES <- toupper(changed)
[01:29:05.163]                 args <- list()
[01:29:05.163]                 for (kk in seq_along(NAMES)) {
[01:29:05.163]                   name <- changed[[kk]]
[01:29:05.163]                   NAME <- NAMES[[kk]]
[01:29:05.163]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:05.163]                     next
[01:29:05.163]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:05.163]                 }
[01:29:05.163]                 NAMES <- toupper(added)
[01:29:05.163]                 for (kk in seq_along(NAMES)) {
[01:29:05.163]                   name <- added[[kk]]
[01:29:05.163]                   NAME <- NAMES[[kk]]
[01:29:05.163]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:05.163]                     next
[01:29:05.163]                   args[[name]] <- ""
[01:29:05.163]                 }
[01:29:05.163]                 NAMES <- toupper(removed)
[01:29:05.163]                 for (kk in seq_along(NAMES)) {
[01:29:05.163]                   name <- removed[[kk]]
[01:29:05.163]                   NAME <- NAMES[[kk]]
[01:29:05.163]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:05.163]                     next
[01:29:05.163]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:05.163]                 }
[01:29:05.163]                 if (length(args) > 0) 
[01:29:05.163]                   base::do.call(base::Sys.setenv, args = args)
[01:29:05.163]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:05.163]             }
[01:29:05.163]             else {
[01:29:05.163]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:05.163]             }
[01:29:05.163]             {
[01:29:05.163]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:05.163]                   0L) {
[01:29:05.163]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:05.163]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:05.163]                   base::options(opts)
[01:29:05.163]                 }
[01:29:05.163]                 {
[01:29:05.163]                   {
[01:29:05.163]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:05.163]                     NULL
[01:29:05.163]                   }
[01:29:05.163]                   options(future.plan = NULL)
[01:29:05.163]                   if (is.na(NA_character_)) 
[01:29:05.163]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:05.163]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:05.163]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:05.163]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:05.163]                     envir = parent.frame()) 
[01:29:05.163]                   {
[01:29:05.163]                     if (is.function(workers)) 
[01:29:05.163]                       workers <- workers()
[01:29:05.163]                     workers <- structure(as.integer(workers), 
[01:29:05.163]                       class = class(workers))
[01:29:05.163]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:05.163]                       workers >= 1)
[01:29:05.163]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:05.163]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:05.163]                     }
[01:29:05.163]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:05.163]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:05.163]                       envir = envir)
[01:29:05.163]                     if (!future$lazy) 
[01:29:05.163]                       future <- run(future)
[01:29:05.163]                     invisible(future)
[01:29:05.163]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:05.163]                 }
[01:29:05.163]             }
[01:29:05.163]         }
[01:29:05.163]     })
[01:29:05.163]     if (TRUE) {
[01:29:05.163]         base::sink(type = "output", split = FALSE)
[01:29:05.163]         if (TRUE) {
[01:29:05.163]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:05.163]         }
[01:29:05.163]         else {
[01:29:05.163]             ...future.result["stdout"] <- base::list(NULL)
[01:29:05.163]         }
[01:29:05.163]         base::close(...future.stdout)
[01:29:05.163]         ...future.stdout <- NULL
[01:29:05.163]     }
[01:29:05.163]     ...future.result$conditions <- ...future.conditions
[01:29:05.163]     ...future.result$finished <- base::Sys.time()
[01:29:05.163]     ...future.result
[01:29:05.163] }
[01:29:05.169] MultisessionFuture started
[01:29:05.169] - Launch lazy future ... done
[01:29:05.169] run() for 'MultisessionFuture' ... done
[01:29:05.690] receiveMessageFromWorker() for ClusterFuture ...
[01:29:05.691] - Validating connection of MultisessionFuture
[01:29:05.691] - received message: FutureResult
[01:29:05.691] - Received FutureResult
[01:29:05.691] - Erased future from FutureRegistry
[01:29:05.691] result() for ClusterFuture ...
[01:29:05.692] - result already collected: FutureResult
[01:29:05.692] result() for ClusterFuture ... done
[01:29:05.692] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:05.692] resolve() on list ...
[01:29:05.692]  recursive: 98
[01:29:05.692]  length: 2
[01:29:05.693]  elements: 'a', 'b'
[01:29:05.693]  length: 1 (resolved future 1)
[01:29:05.693]  length: 0 (resolved future 2)
[01:29:05.693] resolve() on list ... DONE
[01:29:05.693] A MultisessionFuture was resolved (and resolved itself)
[01:29:05.694] getGlobalsAndPackages() ...
[01:29:05.694] Searching for globals...
[01:29:05.695] - globals found: [3] '{', 'Sys.sleep', 'list'
[01:29:05.695] Searching for globals ... DONE
[01:29:05.696] Resolving globals: FALSE
[01:29:05.696] 
[01:29:05.696] 
[01:29:05.696] getGlobalsAndPackages() ... DONE
[01:29:05.697] run() for 'Future' ...
[01:29:05.697] - state: 'created'
[01:29:05.697] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:05.711] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:05.712] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:05.712]   - Field: 'node'
[01:29:05.712]   - Field: 'label'
[01:29:05.712]   - Field: 'local'
[01:29:05.712]   - Field: 'owner'
[01:29:05.713]   - Field: 'envir'
[01:29:05.713]   - Field: 'workers'
[01:29:05.713]   - Field: 'packages'
[01:29:05.713]   - Field: 'gc'
[01:29:05.713]   - Field: 'conditions'
[01:29:05.713]   - Field: 'persistent'
[01:29:05.714]   - Field: 'expr'
[01:29:05.714]   - Field: 'uuid'
[01:29:05.714]   - Field: 'seed'
[01:29:05.714]   - Field: 'version'
[01:29:05.714]   - Field: 'result'
[01:29:05.715]   - Field: 'asynchronous'
[01:29:05.715]   - Field: 'calls'
[01:29:05.715]   - Field: 'globals'
[01:29:05.715]   - Field: 'stdout'
[01:29:05.715]   - Field: 'earlySignal'
[01:29:05.715]   - Field: 'lazy'
[01:29:05.716]   - Field: 'state'
[01:29:05.716] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:05.716] - Launch lazy future ...
[01:29:05.716] Packages needed by the future expression (n = 0): <none>
[01:29:05.717] Packages needed by future strategies (n = 0): <none>
[01:29:05.717] {
[01:29:05.717]     {
[01:29:05.717]         {
[01:29:05.717]             ...future.startTime <- base::Sys.time()
[01:29:05.717]             {
[01:29:05.717]                 {
[01:29:05.717]                   {
[01:29:05.717]                     {
[01:29:05.717]                       base::local({
[01:29:05.717]                         has_future <- base::requireNamespace("future", 
[01:29:05.717]                           quietly = TRUE)
[01:29:05.717]                         if (has_future) {
[01:29:05.717]                           ns <- base::getNamespace("future")
[01:29:05.717]                           version <- ns[[".package"]][["version"]]
[01:29:05.717]                           if (is.null(version)) 
[01:29:05.717]                             version <- utils::packageVersion("future")
[01:29:05.717]                         }
[01:29:05.717]                         else {
[01:29:05.717]                           version <- NULL
[01:29:05.717]                         }
[01:29:05.717]                         if (!has_future || version < "1.8.0") {
[01:29:05.717]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:05.717]                             "", base::R.version$version.string), 
[01:29:05.717]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:05.717]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:05.717]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:05.717]                               "release", "version")], collapse = " "), 
[01:29:05.717]                             hostname = base::Sys.info()[["nodename"]])
[01:29:05.717]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:05.717]                             info)
[01:29:05.717]                           info <- base::paste(info, collapse = "; ")
[01:29:05.717]                           if (!has_future) {
[01:29:05.717]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:05.717]                               info)
[01:29:05.717]                           }
[01:29:05.717]                           else {
[01:29:05.717]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:05.717]                               info, version)
[01:29:05.717]                           }
[01:29:05.717]                           base::stop(msg)
[01:29:05.717]                         }
[01:29:05.717]                       })
[01:29:05.717]                     }
[01:29:05.717]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:05.717]                     base::options(mc.cores = 1L)
[01:29:05.717]                   }
[01:29:05.717]                   options(future.plan = NULL)
[01:29:05.717]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:05.717]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:05.717]                 }
[01:29:05.717]                 ...future.workdir <- getwd()
[01:29:05.717]             }
[01:29:05.717]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:05.717]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:05.717]         }
[01:29:05.717]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:05.717]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:05.717]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:05.717]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:05.717]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:05.717]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:05.717]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:05.717]             base::names(...future.oldOptions))
[01:29:05.717]     }
[01:29:05.717]     if (FALSE) {
[01:29:05.717]     }
[01:29:05.717]     else {
[01:29:05.717]         if (TRUE) {
[01:29:05.717]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:05.717]                 open = "w")
[01:29:05.717]         }
[01:29:05.717]         else {
[01:29:05.717]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:05.717]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:05.717]         }
[01:29:05.717]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:05.717]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:05.717]             base::sink(type = "output", split = FALSE)
[01:29:05.717]             base::close(...future.stdout)
[01:29:05.717]         }, add = TRUE)
[01:29:05.717]     }
[01:29:05.717]     ...future.frame <- base::sys.nframe()
[01:29:05.717]     ...future.conditions <- base::list()
[01:29:05.717]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:05.717]     if (FALSE) {
[01:29:05.717]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:05.717]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:05.717]     }
[01:29:05.717]     ...future.result <- base::tryCatch({
[01:29:05.717]         base::withCallingHandlers({
[01:29:05.717]             ...future.value <- base::withVisible(base::local({
[01:29:05.717]                 ...future.makeSendCondition <- base::local({
[01:29:05.717]                   sendCondition <- NULL
[01:29:05.717]                   function(frame = 1L) {
[01:29:05.717]                     if (is.function(sendCondition)) 
[01:29:05.717]                       return(sendCondition)
[01:29:05.717]                     ns <- getNamespace("parallel")
[01:29:05.717]                     if (exists("sendData", mode = "function", 
[01:29:05.717]                       envir = ns)) {
[01:29:05.717]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:05.717]                         envir = ns)
[01:29:05.717]                       envir <- sys.frame(frame)
[01:29:05.717]                       master <- NULL
[01:29:05.717]                       while (!identical(envir, .GlobalEnv) && 
[01:29:05.717]                         !identical(envir, emptyenv())) {
[01:29:05.717]                         if (exists("master", mode = "list", envir = envir, 
[01:29:05.717]                           inherits = FALSE)) {
[01:29:05.717]                           master <- get("master", mode = "list", 
[01:29:05.717]                             envir = envir, inherits = FALSE)
[01:29:05.717]                           if (inherits(master, c("SOCKnode", 
[01:29:05.717]                             "SOCK0node"))) {
[01:29:05.717]                             sendCondition <<- function(cond) {
[01:29:05.717]                               data <- list(type = "VALUE", value = cond, 
[01:29:05.717]                                 success = TRUE)
[01:29:05.717]                               parallel_sendData(master, data)
[01:29:05.717]                             }
[01:29:05.717]                             return(sendCondition)
[01:29:05.717]                           }
[01:29:05.717]                         }
[01:29:05.717]                         frame <- frame + 1L
[01:29:05.717]                         envir <- sys.frame(frame)
[01:29:05.717]                       }
[01:29:05.717]                     }
[01:29:05.717]                     sendCondition <<- function(cond) NULL
[01:29:05.717]                   }
[01:29:05.717]                 })
[01:29:05.717]                 withCallingHandlers({
[01:29:05.717]                   {
[01:29:05.717]                     Sys.sleep(0.5)
[01:29:05.717]                     list(a = 1, b = 42L)
[01:29:05.717]                   }
[01:29:05.717]                 }, immediateCondition = function(cond) {
[01:29:05.717]                   sendCondition <- ...future.makeSendCondition()
[01:29:05.717]                   sendCondition(cond)
[01:29:05.717]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:05.717]                   {
[01:29:05.717]                     inherits <- base::inherits
[01:29:05.717]                     invokeRestart <- base::invokeRestart
[01:29:05.717]                     is.null <- base::is.null
[01:29:05.717]                     muffled <- FALSE
[01:29:05.717]                     if (inherits(cond, "message")) {
[01:29:05.717]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:05.717]                       if (muffled) 
[01:29:05.717]                         invokeRestart("muffleMessage")
[01:29:05.717]                     }
[01:29:05.717]                     else if (inherits(cond, "warning")) {
[01:29:05.717]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:05.717]                       if (muffled) 
[01:29:05.717]                         invokeRestart("muffleWarning")
[01:29:05.717]                     }
[01:29:05.717]                     else if (inherits(cond, "condition")) {
[01:29:05.717]                       if (!is.null(pattern)) {
[01:29:05.717]                         computeRestarts <- base::computeRestarts
[01:29:05.717]                         grepl <- base::grepl
[01:29:05.717]                         restarts <- computeRestarts(cond)
[01:29:05.717]                         for (restart in restarts) {
[01:29:05.717]                           name <- restart$name
[01:29:05.717]                           if (is.null(name)) 
[01:29:05.717]                             next
[01:29:05.717]                           if (!grepl(pattern, name)) 
[01:29:05.717]                             next
[01:29:05.717]                           invokeRestart(restart)
[01:29:05.717]                           muffled <- TRUE
[01:29:05.717]                           break
[01:29:05.717]                         }
[01:29:05.717]                       }
[01:29:05.717]                     }
[01:29:05.717]                     invisible(muffled)
[01:29:05.717]                   }
[01:29:05.717]                   muffleCondition(cond)
[01:29:05.717]                 })
[01:29:05.717]             }))
[01:29:05.717]             future::FutureResult(value = ...future.value$value, 
[01:29:05.717]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:05.717]                   ...future.rng), globalenv = if (FALSE) 
[01:29:05.717]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:05.717]                     ...future.globalenv.names))
[01:29:05.717]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:05.717]         }, condition = base::local({
[01:29:05.717]             c <- base::c
[01:29:05.717]             inherits <- base::inherits
[01:29:05.717]             invokeRestart <- base::invokeRestart
[01:29:05.717]             length <- base::length
[01:29:05.717]             list <- base::list
[01:29:05.717]             seq.int <- base::seq.int
[01:29:05.717]             signalCondition <- base::signalCondition
[01:29:05.717]             sys.calls <- base::sys.calls
[01:29:05.717]             `[[` <- base::`[[`
[01:29:05.717]             `+` <- base::`+`
[01:29:05.717]             `<<-` <- base::`<<-`
[01:29:05.717]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:05.717]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:05.717]                   3L)]
[01:29:05.717]             }
[01:29:05.717]             function(cond) {
[01:29:05.717]                 is_error <- inherits(cond, "error")
[01:29:05.717]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:05.717]                   NULL)
[01:29:05.717]                 if (is_error) {
[01:29:05.717]                   sessionInformation <- function() {
[01:29:05.717]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:05.717]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:05.717]                       search = base::search(), system = base::Sys.info())
[01:29:05.717]                   }
[01:29:05.717]                   ...future.conditions[[length(...future.conditions) + 
[01:29:05.717]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:05.717]                     cond$call), session = sessionInformation(), 
[01:29:05.717]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:05.717]                   signalCondition(cond)
[01:29:05.717]                 }
[01:29:05.717]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:05.717]                 "immediateCondition"))) {
[01:29:05.717]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:05.717]                   ...future.conditions[[length(...future.conditions) + 
[01:29:05.717]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:05.717]                   if (TRUE && !signal) {
[01:29:05.717]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:05.717]                     {
[01:29:05.717]                       inherits <- base::inherits
[01:29:05.717]                       invokeRestart <- base::invokeRestart
[01:29:05.717]                       is.null <- base::is.null
[01:29:05.717]                       muffled <- FALSE
[01:29:05.717]                       if (inherits(cond, "message")) {
[01:29:05.717]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:05.717]                         if (muffled) 
[01:29:05.717]                           invokeRestart("muffleMessage")
[01:29:05.717]                       }
[01:29:05.717]                       else if (inherits(cond, "warning")) {
[01:29:05.717]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:05.717]                         if (muffled) 
[01:29:05.717]                           invokeRestart("muffleWarning")
[01:29:05.717]                       }
[01:29:05.717]                       else if (inherits(cond, "condition")) {
[01:29:05.717]                         if (!is.null(pattern)) {
[01:29:05.717]                           computeRestarts <- base::computeRestarts
[01:29:05.717]                           grepl <- base::grepl
[01:29:05.717]                           restarts <- computeRestarts(cond)
[01:29:05.717]                           for (restart in restarts) {
[01:29:05.717]                             name <- restart$name
[01:29:05.717]                             if (is.null(name)) 
[01:29:05.717]                               next
[01:29:05.717]                             if (!grepl(pattern, name)) 
[01:29:05.717]                               next
[01:29:05.717]                             invokeRestart(restart)
[01:29:05.717]                             muffled <- TRUE
[01:29:05.717]                             break
[01:29:05.717]                           }
[01:29:05.717]                         }
[01:29:05.717]                       }
[01:29:05.717]                       invisible(muffled)
[01:29:05.717]                     }
[01:29:05.717]                     muffleCondition(cond, pattern = "^muffle")
[01:29:05.717]                   }
[01:29:05.717]                 }
[01:29:05.717]                 else {
[01:29:05.717]                   if (TRUE) {
[01:29:05.717]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:05.717]                     {
[01:29:05.717]                       inherits <- base::inherits
[01:29:05.717]                       invokeRestart <- base::invokeRestart
[01:29:05.717]                       is.null <- base::is.null
[01:29:05.717]                       muffled <- FALSE
[01:29:05.717]                       if (inherits(cond, "message")) {
[01:29:05.717]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:05.717]                         if (muffled) 
[01:29:05.717]                           invokeRestart("muffleMessage")
[01:29:05.717]                       }
[01:29:05.717]                       else if (inherits(cond, "warning")) {
[01:29:05.717]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:05.717]                         if (muffled) 
[01:29:05.717]                           invokeRestart("muffleWarning")
[01:29:05.717]                       }
[01:29:05.717]                       else if (inherits(cond, "condition")) {
[01:29:05.717]                         if (!is.null(pattern)) {
[01:29:05.717]                           computeRestarts <- base::computeRestarts
[01:29:05.717]                           grepl <- base::grepl
[01:29:05.717]                           restarts <- computeRestarts(cond)
[01:29:05.717]                           for (restart in restarts) {
[01:29:05.717]                             name <- restart$name
[01:29:05.717]                             if (is.null(name)) 
[01:29:05.717]                               next
[01:29:05.717]                             if (!grepl(pattern, name)) 
[01:29:05.717]                               next
[01:29:05.717]                             invokeRestart(restart)
[01:29:05.717]                             muffled <- TRUE
[01:29:05.717]                             break
[01:29:05.717]                           }
[01:29:05.717]                         }
[01:29:05.717]                       }
[01:29:05.717]                       invisible(muffled)
[01:29:05.717]                     }
[01:29:05.717]                     muffleCondition(cond, pattern = "^muffle")
[01:29:05.717]                   }
[01:29:05.717]                 }
[01:29:05.717]             }
[01:29:05.717]         }))
[01:29:05.717]     }, error = function(ex) {
[01:29:05.717]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:05.717]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:05.717]                 ...future.rng), started = ...future.startTime, 
[01:29:05.717]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:05.717]             version = "1.8"), class = "FutureResult")
[01:29:05.717]     }, finally = {
[01:29:05.717]         if (!identical(...future.workdir, getwd())) 
[01:29:05.717]             setwd(...future.workdir)
[01:29:05.717]         {
[01:29:05.717]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:05.717]                 ...future.oldOptions$nwarnings <- NULL
[01:29:05.717]             }
[01:29:05.717]             base::options(...future.oldOptions)
[01:29:05.717]             if (.Platform$OS.type == "windows") {
[01:29:05.717]                 old_names <- names(...future.oldEnvVars)
[01:29:05.717]                 envs <- base::Sys.getenv()
[01:29:05.717]                 names <- names(envs)
[01:29:05.717]                 common <- intersect(names, old_names)
[01:29:05.717]                 added <- setdiff(names, old_names)
[01:29:05.717]                 removed <- setdiff(old_names, names)
[01:29:05.717]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:05.717]                   envs[common]]
[01:29:05.717]                 NAMES <- toupper(changed)
[01:29:05.717]                 args <- list()
[01:29:05.717]                 for (kk in seq_along(NAMES)) {
[01:29:05.717]                   name <- changed[[kk]]
[01:29:05.717]                   NAME <- NAMES[[kk]]
[01:29:05.717]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:05.717]                     next
[01:29:05.717]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:05.717]                 }
[01:29:05.717]                 NAMES <- toupper(added)
[01:29:05.717]                 for (kk in seq_along(NAMES)) {
[01:29:05.717]                   name <- added[[kk]]
[01:29:05.717]                   NAME <- NAMES[[kk]]
[01:29:05.717]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:05.717]                     next
[01:29:05.717]                   args[[name]] <- ""
[01:29:05.717]                 }
[01:29:05.717]                 NAMES <- toupper(removed)
[01:29:05.717]                 for (kk in seq_along(NAMES)) {
[01:29:05.717]                   name <- removed[[kk]]
[01:29:05.717]                   NAME <- NAMES[[kk]]
[01:29:05.717]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:05.717]                     next
[01:29:05.717]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:05.717]                 }
[01:29:05.717]                 if (length(args) > 0) 
[01:29:05.717]                   base::do.call(base::Sys.setenv, args = args)
[01:29:05.717]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:05.717]             }
[01:29:05.717]             else {
[01:29:05.717]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:05.717]             }
[01:29:05.717]             {
[01:29:05.717]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:05.717]                   0L) {
[01:29:05.717]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:05.717]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:05.717]                   base::options(opts)
[01:29:05.717]                 }
[01:29:05.717]                 {
[01:29:05.717]                   {
[01:29:05.717]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:05.717]                     NULL
[01:29:05.717]                   }
[01:29:05.717]                   options(future.plan = NULL)
[01:29:05.717]                   if (is.na(NA_character_)) 
[01:29:05.717]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:05.717]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:05.717]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:05.717]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:05.717]                     envir = parent.frame()) 
[01:29:05.717]                   {
[01:29:05.717]                     if (is.function(workers)) 
[01:29:05.717]                       workers <- workers()
[01:29:05.717]                     workers <- structure(as.integer(workers), 
[01:29:05.717]                       class = class(workers))
[01:29:05.717]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:05.717]                       workers >= 1)
[01:29:05.717]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:05.717]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:05.717]                     }
[01:29:05.717]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:05.717]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:05.717]                       envir = envir)
[01:29:05.717]                     if (!future$lazy) 
[01:29:05.717]                       future <- run(future)
[01:29:05.717]                     invisible(future)
[01:29:05.717]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:05.717]                 }
[01:29:05.717]             }
[01:29:05.717]         }
[01:29:05.717]     })
[01:29:05.717]     if (TRUE) {
[01:29:05.717]         base::sink(type = "output", split = FALSE)
[01:29:05.717]         if (TRUE) {
[01:29:05.717]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:05.717]         }
[01:29:05.717]         else {
[01:29:05.717]             ...future.result["stdout"] <- base::list(NULL)
[01:29:05.717]         }
[01:29:05.717]         base::close(...future.stdout)
[01:29:05.717]         ...future.stdout <- NULL
[01:29:05.717]     }
[01:29:05.717]     ...future.result$conditions <- ...future.conditions
[01:29:05.717]     ...future.result$finished <- base::Sys.time()
[01:29:05.717]     ...future.result
[01:29:05.717] }
[01:29:05.723] MultisessionFuture started
[01:29:05.723] - Launch lazy future ... done
[01:29:05.723] run() for 'MultisessionFuture' ... done
[01:29:06.265] receiveMessageFromWorker() for ClusterFuture ...
[01:29:06.265] - Validating connection of MultisessionFuture
[01:29:06.266] - received message: FutureResult
[01:29:06.266] - Received FutureResult
[01:29:06.266] - Erased future from FutureRegistry
[01:29:06.266] result() for ClusterFuture ...
[01:29:06.267] - result already collected: FutureResult
[01:29:06.267] result() for ClusterFuture ... done
[01:29:06.267] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:06.267] resolve() on list ...
[01:29:06.267]  recursive: 98
[01:29:06.267]  length: 2
[01:29:06.268]  elements: 'a', 'b'
[01:29:06.268]  length: 1 (resolved future 1)
[01:29:06.268]  length: 0 (resolved future 2)
[01:29:06.268] resolve() on list ... DONE
[01:29:06.268] A MultisessionFuture was resolved (and resolved itself)
- w/ exception ...
[01:29:06.269] getGlobalsAndPackages() ...
[01:29:06.269] Searching for globals...
[01:29:06.269] - globals found: [2] 'list', 'stop'
[01:29:06.270] Searching for globals ... DONE
[01:29:06.270] Resolving globals: FALSE
[01:29:06.270] 
[01:29:06.270] 
[01:29:06.271] getGlobalsAndPackages() ... DONE
[01:29:06.271] run() for 'Future' ...
[01:29:06.271] - state: 'created'
[01:29:06.271] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:06.286] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:06.286] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:06.286]   - Field: 'node'
[01:29:06.286]   - Field: 'label'
[01:29:06.286]   - Field: 'local'
[01:29:06.286]   - Field: 'owner'
[01:29:06.287]   - Field: 'envir'
[01:29:06.287]   - Field: 'workers'
[01:29:06.287]   - Field: 'packages'
[01:29:06.287]   - Field: 'gc'
[01:29:06.287]   - Field: 'conditions'
[01:29:06.288]   - Field: 'persistent'
[01:29:06.288]   - Field: 'expr'
[01:29:06.288]   - Field: 'uuid'
[01:29:06.288]   - Field: 'seed'
[01:29:06.288]   - Field: 'version'
[01:29:06.288]   - Field: 'result'
[01:29:06.289]   - Field: 'asynchronous'
[01:29:06.289]   - Field: 'calls'
[01:29:06.289]   - Field: 'globals'
[01:29:06.289]   - Field: 'stdout'
[01:29:06.289]   - Field: 'earlySignal'
[01:29:06.289]   - Field: 'lazy'
[01:29:06.290]   - Field: 'state'
[01:29:06.290] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:06.290] - Launch lazy future ...
[01:29:06.290] Packages needed by the future expression (n = 0): <none>
[01:29:06.291] Packages needed by future strategies (n = 0): <none>
[01:29:06.291] {
[01:29:06.291]     {
[01:29:06.291]         {
[01:29:06.291]             ...future.startTime <- base::Sys.time()
[01:29:06.291]             {
[01:29:06.291]                 {
[01:29:06.291]                   {
[01:29:06.291]                     {
[01:29:06.291]                       base::local({
[01:29:06.291]                         has_future <- base::requireNamespace("future", 
[01:29:06.291]                           quietly = TRUE)
[01:29:06.291]                         if (has_future) {
[01:29:06.291]                           ns <- base::getNamespace("future")
[01:29:06.291]                           version <- ns[[".package"]][["version"]]
[01:29:06.291]                           if (is.null(version)) 
[01:29:06.291]                             version <- utils::packageVersion("future")
[01:29:06.291]                         }
[01:29:06.291]                         else {
[01:29:06.291]                           version <- NULL
[01:29:06.291]                         }
[01:29:06.291]                         if (!has_future || version < "1.8.0") {
[01:29:06.291]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:06.291]                             "", base::R.version$version.string), 
[01:29:06.291]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:06.291]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:06.291]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:06.291]                               "release", "version")], collapse = " "), 
[01:29:06.291]                             hostname = base::Sys.info()[["nodename"]])
[01:29:06.291]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:06.291]                             info)
[01:29:06.291]                           info <- base::paste(info, collapse = "; ")
[01:29:06.291]                           if (!has_future) {
[01:29:06.291]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:06.291]                               info)
[01:29:06.291]                           }
[01:29:06.291]                           else {
[01:29:06.291]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:06.291]                               info, version)
[01:29:06.291]                           }
[01:29:06.291]                           base::stop(msg)
[01:29:06.291]                         }
[01:29:06.291]                       })
[01:29:06.291]                     }
[01:29:06.291]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:06.291]                     base::options(mc.cores = 1L)
[01:29:06.291]                   }
[01:29:06.291]                   options(future.plan = NULL)
[01:29:06.291]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:06.291]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:06.291]                 }
[01:29:06.291]                 ...future.workdir <- getwd()
[01:29:06.291]             }
[01:29:06.291]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:06.291]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:06.291]         }
[01:29:06.291]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:06.291]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:06.291]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:06.291]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:06.291]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:06.291]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:06.291]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:06.291]             base::names(...future.oldOptions))
[01:29:06.291]     }
[01:29:06.291]     if (FALSE) {
[01:29:06.291]     }
[01:29:06.291]     else {
[01:29:06.291]         if (TRUE) {
[01:29:06.291]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:06.291]                 open = "w")
[01:29:06.291]         }
[01:29:06.291]         else {
[01:29:06.291]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:06.291]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:06.291]         }
[01:29:06.291]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:06.291]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:06.291]             base::sink(type = "output", split = FALSE)
[01:29:06.291]             base::close(...future.stdout)
[01:29:06.291]         }, add = TRUE)
[01:29:06.291]     }
[01:29:06.291]     ...future.frame <- base::sys.nframe()
[01:29:06.291]     ...future.conditions <- base::list()
[01:29:06.291]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:06.291]     if (FALSE) {
[01:29:06.291]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:06.291]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:06.291]     }
[01:29:06.291]     ...future.result <- base::tryCatch({
[01:29:06.291]         base::withCallingHandlers({
[01:29:06.291]             ...future.value <- base::withVisible(base::local({
[01:29:06.291]                 ...future.makeSendCondition <- base::local({
[01:29:06.291]                   sendCondition <- NULL
[01:29:06.291]                   function(frame = 1L) {
[01:29:06.291]                     if (is.function(sendCondition)) 
[01:29:06.291]                       return(sendCondition)
[01:29:06.291]                     ns <- getNamespace("parallel")
[01:29:06.291]                     if (exists("sendData", mode = "function", 
[01:29:06.291]                       envir = ns)) {
[01:29:06.291]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:06.291]                         envir = ns)
[01:29:06.291]                       envir <- sys.frame(frame)
[01:29:06.291]                       master <- NULL
[01:29:06.291]                       while (!identical(envir, .GlobalEnv) && 
[01:29:06.291]                         !identical(envir, emptyenv())) {
[01:29:06.291]                         if (exists("master", mode = "list", envir = envir, 
[01:29:06.291]                           inherits = FALSE)) {
[01:29:06.291]                           master <- get("master", mode = "list", 
[01:29:06.291]                             envir = envir, inherits = FALSE)
[01:29:06.291]                           if (inherits(master, c("SOCKnode", 
[01:29:06.291]                             "SOCK0node"))) {
[01:29:06.291]                             sendCondition <<- function(cond) {
[01:29:06.291]                               data <- list(type = "VALUE", value = cond, 
[01:29:06.291]                                 success = TRUE)
[01:29:06.291]                               parallel_sendData(master, data)
[01:29:06.291]                             }
[01:29:06.291]                             return(sendCondition)
[01:29:06.291]                           }
[01:29:06.291]                         }
[01:29:06.291]                         frame <- frame + 1L
[01:29:06.291]                         envir <- sys.frame(frame)
[01:29:06.291]                       }
[01:29:06.291]                     }
[01:29:06.291]                     sendCondition <<- function(cond) NULL
[01:29:06.291]                   }
[01:29:06.291]                 })
[01:29:06.291]                 withCallingHandlers({
[01:29:06.291]                   list(a = 1, b = 42L, c = stop("Nah!"))
[01:29:06.291]                 }, immediateCondition = function(cond) {
[01:29:06.291]                   sendCondition <- ...future.makeSendCondition()
[01:29:06.291]                   sendCondition(cond)
[01:29:06.291]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:06.291]                   {
[01:29:06.291]                     inherits <- base::inherits
[01:29:06.291]                     invokeRestart <- base::invokeRestart
[01:29:06.291]                     is.null <- base::is.null
[01:29:06.291]                     muffled <- FALSE
[01:29:06.291]                     if (inherits(cond, "message")) {
[01:29:06.291]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:06.291]                       if (muffled) 
[01:29:06.291]                         invokeRestart("muffleMessage")
[01:29:06.291]                     }
[01:29:06.291]                     else if (inherits(cond, "warning")) {
[01:29:06.291]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:06.291]                       if (muffled) 
[01:29:06.291]                         invokeRestart("muffleWarning")
[01:29:06.291]                     }
[01:29:06.291]                     else if (inherits(cond, "condition")) {
[01:29:06.291]                       if (!is.null(pattern)) {
[01:29:06.291]                         computeRestarts <- base::computeRestarts
[01:29:06.291]                         grepl <- base::grepl
[01:29:06.291]                         restarts <- computeRestarts(cond)
[01:29:06.291]                         for (restart in restarts) {
[01:29:06.291]                           name <- restart$name
[01:29:06.291]                           if (is.null(name)) 
[01:29:06.291]                             next
[01:29:06.291]                           if (!grepl(pattern, name)) 
[01:29:06.291]                             next
[01:29:06.291]                           invokeRestart(restart)
[01:29:06.291]                           muffled <- TRUE
[01:29:06.291]                           break
[01:29:06.291]                         }
[01:29:06.291]                       }
[01:29:06.291]                     }
[01:29:06.291]                     invisible(muffled)
[01:29:06.291]                   }
[01:29:06.291]                   muffleCondition(cond)
[01:29:06.291]                 })
[01:29:06.291]             }))
[01:29:06.291]             future::FutureResult(value = ...future.value$value, 
[01:29:06.291]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:06.291]                   ...future.rng), globalenv = if (FALSE) 
[01:29:06.291]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:06.291]                     ...future.globalenv.names))
[01:29:06.291]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:06.291]         }, condition = base::local({
[01:29:06.291]             c <- base::c
[01:29:06.291]             inherits <- base::inherits
[01:29:06.291]             invokeRestart <- base::invokeRestart
[01:29:06.291]             length <- base::length
[01:29:06.291]             list <- base::list
[01:29:06.291]             seq.int <- base::seq.int
[01:29:06.291]             signalCondition <- base::signalCondition
[01:29:06.291]             sys.calls <- base::sys.calls
[01:29:06.291]             `[[` <- base::`[[`
[01:29:06.291]             `+` <- base::`+`
[01:29:06.291]             `<<-` <- base::`<<-`
[01:29:06.291]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:06.291]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:06.291]                   3L)]
[01:29:06.291]             }
[01:29:06.291]             function(cond) {
[01:29:06.291]                 is_error <- inherits(cond, "error")
[01:29:06.291]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:06.291]                   NULL)
[01:29:06.291]                 if (is_error) {
[01:29:06.291]                   sessionInformation <- function() {
[01:29:06.291]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:06.291]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:06.291]                       search = base::search(), system = base::Sys.info())
[01:29:06.291]                   }
[01:29:06.291]                   ...future.conditions[[length(...future.conditions) + 
[01:29:06.291]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:06.291]                     cond$call), session = sessionInformation(), 
[01:29:06.291]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:06.291]                   signalCondition(cond)
[01:29:06.291]                 }
[01:29:06.291]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:06.291]                 "immediateCondition"))) {
[01:29:06.291]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:06.291]                   ...future.conditions[[length(...future.conditions) + 
[01:29:06.291]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:06.291]                   if (TRUE && !signal) {
[01:29:06.291]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:06.291]                     {
[01:29:06.291]                       inherits <- base::inherits
[01:29:06.291]                       invokeRestart <- base::invokeRestart
[01:29:06.291]                       is.null <- base::is.null
[01:29:06.291]                       muffled <- FALSE
[01:29:06.291]                       if (inherits(cond, "message")) {
[01:29:06.291]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:06.291]                         if (muffled) 
[01:29:06.291]                           invokeRestart("muffleMessage")
[01:29:06.291]                       }
[01:29:06.291]                       else if (inherits(cond, "warning")) {
[01:29:06.291]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:06.291]                         if (muffled) 
[01:29:06.291]                           invokeRestart("muffleWarning")
[01:29:06.291]                       }
[01:29:06.291]                       else if (inherits(cond, "condition")) {
[01:29:06.291]                         if (!is.null(pattern)) {
[01:29:06.291]                           computeRestarts <- base::computeRestarts
[01:29:06.291]                           grepl <- base::grepl
[01:29:06.291]                           restarts <- computeRestarts(cond)
[01:29:06.291]                           for (restart in restarts) {
[01:29:06.291]                             name <- restart$name
[01:29:06.291]                             if (is.null(name)) 
[01:29:06.291]                               next
[01:29:06.291]                             if (!grepl(pattern, name)) 
[01:29:06.291]                               next
[01:29:06.291]                             invokeRestart(restart)
[01:29:06.291]                             muffled <- TRUE
[01:29:06.291]                             break
[01:29:06.291]                           }
[01:29:06.291]                         }
[01:29:06.291]                       }
[01:29:06.291]                       invisible(muffled)
[01:29:06.291]                     }
[01:29:06.291]                     muffleCondition(cond, pattern = "^muffle")
[01:29:06.291]                   }
[01:29:06.291]                 }
[01:29:06.291]                 else {
[01:29:06.291]                   if (TRUE) {
[01:29:06.291]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:06.291]                     {
[01:29:06.291]                       inherits <- base::inherits
[01:29:06.291]                       invokeRestart <- base::invokeRestart
[01:29:06.291]                       is.null <- base::is.null
[01:29:06.291]                       muffled <- FALSE
[01:29:06.291]                       if (inherits(cond, "message")) {
[01:29:06.291]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:06.291]                         if (muffled) 
[01:29:06.291]                           invokeRestart("muffleMessage")
[01:29:06.291]                       }
[01:29:06.291]                       else if (inherits(cond, "warning")) {
[01:29:06.291]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:06.291]                         if (muffled) 
[01:29:06.291]                           invokeRestart("muffleWarning")
[01:29:06.291]                       }
[01:29:06.291]                       else if (inherits(cond, "condition")) {
[01:29:06.291]                         if (!is.null(pattern)) {
[01:29:06.291]                           computeRestarts <- base::computeRestarts
[01:29:06.291]                           grepl <- base::grepl
[01:29:06.291]                           restarts <- computeRestarts(cond)
[01:29:06.291]                           for (restart in restarts) {
[01:29:06.291]                             name <- restart$name
[01:29:06.291]                             if (is.null(name)) 
[01:29:06.291]                               next
[01:29:06.291]                             if (!grepl(pattern, name)) 
[01:29:06.291]                               next
[01:29:06.291]                             invokeRestart(restart)
[01:29:06.291]                             muffled <- TRUE
[01:29:06.291]                             break
[01:29:06.291]                           }
[01:29:06.291]                         }
[01:29:06.291]                       }
[01:29:06.291]                       invisible(muffled)
[01:29:06.291]                     }
[01:29:06.291]                     muffleCondition(cond, pattern = "^muffle")
[01:29:06.291]                   }
[01:29:06.291]                 }
[01:29:06.291]             }
[01:29:06.291]         }))
[01:29:06.291]     }, error = function(ex) {
[01:29:06.291]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:06.291]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:06.291]                 ...future.rng), started = ...future.startTime, 
[01:29:06.291]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:06.291]             version = "1.8"), class = "FutureResult")
[01:29:06.291]     }, finally = {
[01:29:06.291]         if (!identical(...future.workdir, getwd())) 
[01:29:06.291]             setwd(...future.workdir)
[01:29:06.291]         {
[01:29:06.291]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:06.291]                 ...future.oldOptions$nwarnings <- NULL
[01:29:06.291]             }
[01:29:06.291]             base::options(...future.oldOptions)
[01:29:06.291]             if (.Platform$OS.type == "windows") {
[01:29:06.291]                 old_names <- names(...future.oldEnvVars)
[01:29:06.291]                 envs <- base::Sys.getenv()
[01:29:06.291]                 names <- names(envs)
[01:29:06.291]                 common <- intersect(names, old_names)
[01:29:06.291]                 added <- setdiff(names, old_names)
[01:29:06.291]                 removed <- setdiff(old_names, names)
[01:29:06.291]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:06.291]                   envs[common]]
[01:29:06.291]                 NAMES <- toupper(changed)
[01:29:06.291]                 args <- list()
[01:29:06.291]                 for (kk in seq_along(NAMES)) {
[01:29:06.291]                   name <- changed[[kk]]
[01:29:06.291]                   NAME <- NAMES[[kk]]
[01:29:06.291]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:06.291]                     next
[01:29:06.291]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:06.291]                 }
[01:29:06.291]                 NAMES <- toupper(added)
[01:29:06.291]                 for (kk in seq_along(NAMES)) {
[01:29:06.291]                   name <- added[[kk]]
[01:29:06.291]                   NAME <- NAMES[[kk]]
[01:29:06.291]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:06.291]                     next
[01:29:06.291]                   args[[name]] <- ""
[01:29:06.291]                 }
[01:29:06.291]                 NAMES <- toupper(removed)
[01:29:06.291]                 for (kk in seq_along(NAMES)) {
[01:29:06.291]                   name <- removed[[kk]]
[01:29:06.291]                   NAME <- NAMES[[kk]]
[01:29:06.291]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:06.291]                     next
[01:29:06.291]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:06.291]                 }
[01:29:06.291]                 if (length(args) > 0) 
[01:29:06.291]                   base::do.call(base::Sys.setenv, args = args)
[01:29:06.291]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:06.291]             }
[01:29:06.291]             else {
[01:29:06.291]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:06.291]             }
[01:29:06.291]             {
[01:29:06.291]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:06.291]                   0L) {
[01:29:06.291]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:06.291]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:06.291]                   base::options(opts)
[01:29:06.291]                 }
[01:29:06.291]                 {
[01:29:06.291]                   {
[01:29:06.291]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:06.291]                     NULL
[01:29:06.291]                   }
[01:29:06.291]                   options(future.plan = NULL)
[01:29:06.291]                   if (is.na(NA_character_)) 
[01:29:06.291]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:06.291]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:06.291]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:06.291]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:06.291]                     envir = parent.frame()) 
[01:29:06.291]                   {
[01:29:06.291]                     if (is.function(workers)) 
[01:29:06.291]                       workers <- workers()
[01:29:06.291]                     workers <- structure(as.integer(workers), 
[01:29:06.291]                       class = class(workers))
[01:29:06.291]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:06.291]                       workers >= 1)
[01:29:06.291]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:06.291]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:06.291]                     }
[01:29:06.291]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:06.291]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:06.291]                       envir = envir)
[01:29:06.291]                     if (!future$lazy) 
[01:29:06.291]                       future <- run(future)
[01:29:06.291]                     invisible(future)
[01:29:06.291]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:06.291]                 }
[01:29:06.291]             }
[01:29:06.291]         }
[01:29:06.291]     })
[01:29:06.291]     if (TRUE) {
[01:29:06.291]         base::sink(type = "output", split = FALSE)
[01:29:06.291]         if (TRUE) {
[01:29:06.291]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:06.291]         }
[01:29:06.291]         else {
[01:29:06.291]             ...future.result["stdout"] <- base::list(NULL)
[01:29:06.291]         }
[01:29:06.291]         base::close(...future.stdout)
[01:29:06.291]         ...future.stdout <- NULL
[01:29:06.291]     }
[01:29:06.291]     ...future.result$conditions <- ...future.conditions
[01:29:06.291]     ...future.result$finished <- base::Sys.time()
[01:29:06.291]     ...future.result
[01:29:06.291] }
[01:29:06.297] MultisessionFuture started
[01:29:06.297] - Launch lazy future ... done
[01:29:06.297] run() for 'MultisessionFuture' ... done
[01:29:06.319] receiveMessageFromWorker() for ClusterFuture ...
[01:29:06.320] - Validating connection of MultisessionFuture
[01:29:06.320] - received message: FutureResult
[01:29:06.320] - Received FutureResult
[01:29:06.321] - Erased future from FutureRegistry
[01:29:06.321] result() for ClusterFuture ...
[01:29:06.321] - result already collected: FutureResult
[01:29:06.321] result() for ClusterFuture ... done
[01:29:06.321] signalConditions() ...
[01:29:06.321]  - include = 'immediateCondition'
[01:29:06.322]  - exclude = 
[01:29:06.322]  - resignal = FALSE
[01:29:06.322]  - Number of conditions: 1
[01:29:06.322] signalConditions() ... done
[01:29:06.322] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:06.322] A MultisessionFuture was resolved (and resolved itself)
[01:29:06.323] getGlobalsAndPackages() ...
[01:29:06.323] Searching for globals...
[01:29:06.324] - globals found: [2] 'list', 'stop'
[01:29:06.324] Searching for globals ... DONE
[01:29:06.324] Resolving globals: FALSE
[01:29:06.324] 
[01:29:06.325] 
[01:29:06.325] getGlobalsAndPackages() ... DONE
[01:29:06.325] run() for 'Future' ...
[01:29:06.325] - state: 'created'
[01:29:06.325] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:06.340] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:06.340] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:06.340]   - Field: 'node'
[01:29:06.340]   - Field: 'label'
[01:29:06.340]   - Field: 'local'
[01:29:06.340]   - Field: 'owner'
[01:29:06.341]   - Field: 'envir'
[01:29:06.341]   - Field: 'workers'
[01:29:06.341]   - Field: 'packages'
[01:29:06.341]   - Field: 'gc'
[01:29:06.341]   - Field: 'conditions'
[01:29:06.342]   - Field: 'persistent'
[01:29:06.342]   - Field: 'expr'
[01:29:06.342]   - Field: 'uuid'
[01:29:06.342]   - Field: 'seed'
[01:29:06.342]   - Field: 'version'
[01:29:06.342]   - Field: 'result'
[01:29:06.343]   - Field: 'asynchronous'
[01:29:06.343]   - Field: 'calls'
[01:29:06.343]   - Field: 'globals'
[01:29:06.343]   - Field: 'stdout'
[01:29:06.343]   - Field: 'earlySignal'
[01:29:06.344]   - Field: 'lazy'
[01:29:06.344]   - Field: 'state'
[01:29:06.344] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:06.344] - Launch lazy future ...
[01:29:06.344] Packages needed by the future expression (n = 0): <none>
[01:29:06.345] Packages needed by future strategies (n = 0): <none>
[01:29:06.345] {
[01:29:06.345]     {
[01:29:06.345]         {
[01:29:06.345]             ...future.startTime <- base::Sys.time()
[01:29:06.345]             {
[01:29:06.345]                 {
[01:29:06.345]                   {
[01:29:06.345]                     {
[01:29:06.345]                       base::local({
[01:29:06.345]                         has_future <- base::requireNamespace("future", 
[01:29:06.345]                           quietly = TRUE)
[01:29:06.345]                         if (has_future) {
[01:29:06.345]                           ns <- base::getNamespace("future")
[01:29:06.345]                           version <- ns[[".package"]][["version"]]
[01:29:06.345]                           if (is.null(version)) 
[01:29:06.345]                             version <- utils::packageVersion("future")
[01:29:06.345]                         }
[01:29:06.345]                         else {
[01:29:06.345]                           version <- NULL
[01:29:06.345]                         }
[01:29:06.345]                         if (!has_future || version < "1.8.0") {
[01:29:06.345]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:06.345]                             "", base::R.version$version.string), 
[01:29:06.345]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:06.345]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:06.345]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:06.345]                               "release", "version")], collapse = " "), 
[01:29:06.345]                             hostname = base::Sys.info()[["nodename"]])
[01:29:06.345]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:06.345]                             info)
[01:29:06.345]                           info <- base::paste(info, collapse = "; ")
[01:29:06.345]                           if (!has_future) {
[01:29:06.345]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:06.345]                               info)
[01:29:06.345]                           }
[01:29:06.345]                           else {
[01:29:06.345]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:06.345]                               info, version)
[01:29:06.345]                           }
[01:29:06.345]                           base::stop(msg)
[01:29:06.345]                         }
[01:29:06.345]                       })
[01:29:06.345]                     }
[01:29:06.345]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:06.345]                     base::options(mc.cores = 1L)
[01:29:06.345]                   }
[01:29:06.345]                   options(future.plan = NULL)
[01:29:06.345]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:06.345]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:06.345]                 }
[01:29:06.345]                 ...future.workdir <- getwd()
[01:29:06.345]             }
[01:29:06.345]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:06.345]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:06.345]         }
[01:29:06.345]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:06.345]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:06.345]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:06.345]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:06.345]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:06.345]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:06.345]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:06.345]             base::names(...future.oldOptions))
[01:29:06.345]     }
[01:29:06.345]     if (FALSE) {
[01:29:06.345]     }
[01:29:06.345]     else {
[01:29:06.345]         if (TRUE) {
[01:29:06.345]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:06.345]                 open = "w")
[01:29:06.345]         }
[01:29:06.345]         else {
[01:29:06.345]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:06.345]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:06.345]         }
[01:29:06.345]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:06.345]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:06.345]             base::sink(type = "output", split = FALSE)
[01:29:06.345]             base::close(...future.stdout)
[01:29:06.345]         }, add = TRUE)
[01:29:06.345]     }
[01:29:06.345]     ...future.frame <- base::sys.nframe()
[01:29:06.345]     ...future.conditions <- base::list()
[01:29:06.345]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:06.345]     if (FALSE) {
[01:29:06.345]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:06.345]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:06.345]     }
[01:29:06.345]     ...future.result <- base::tryCatch({
[01:29:06.345]         base::withCallingHandlers({
[01:29:06.345]             ...future.value <- base::withVisible(base::local({
[01:29:06.345]                 ...future.makeSendCondition <- base::local({
[01:29:06.345]                   sendCondition <- NULL
[01:29:06.345]                   function(frame = 1L) {
[01:29:06.345]                     if (is.function(sendCondition)) 
[01:29:06.345]                       return(sendCondition)
[01:29:06.345]                     ns <- getNamespace("parallel")
[01:29:06.345]                     if (exists("sendData", mode = "function", 
[01:29:06.345]                       envir = ns)) {
[01:29:06.345]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:06.345]                         envir = ns)
[01:29:06.345]                       envir <- sys.frame(frame)
[01:29:06.345]                       master <- NULL
[01:29:06.345]                       while (!identical(envir, .GlobalEnv) && 
[01:29:06.345]                         !identical(envir, emptyenv())) {
[01:29:06.345]                         if (exists("master", mode = "list", envir = envir, 
[01:29:06.345]                           inherits = FALSE)) {
[01:29:06.345]                           master <- get("master", mode = "list", 
[01:29:06.345]                             envir = envir, inherits = FALSE)
[01:29:06.345]                           if (inherits(master, c("SOCKnode", 
[01:29:06.345]                             "SOCK0node"))) {
[01:29:06.345]                             sendCondition <<- function(cond) {
[01:29:06.345]                               data <- list(type = "VALUE", value = cond, 
[01:29:06.345]                                 success = TRUE)
[01:29:06.345]                               parallel_sendData(master, data)
[01:29:06.345]                             }
[01:29:06.345]                             return(sendCondition)
[01:29:06.345]                           }
[01:29:06.345]                         }
[01:29:06.345]                         frame <- frame + 1L
[01:29:06.345]                         envir <- sys.frame(frame)
[01:29:06.345]                       }
[01:29:06.345]                     }
[01:29:06.345]                     sendCondition <<- function(cond) NULL
[01:29:06.345]                   }
[01:29:06.345]                 })
[01:29:06.345]                 withCallingHandlers({
[01:29:06.345]                   list(a = 1, b = 42L, c = stop("Nah!"))
[01:29:06.345]                 }, immediateCondition = function(cond) {
[01:29:06.345]                   sendCondition <- ...future.makeSendCondition()
[01:29:06.345]                   sendCondition(cond)
[01:29:06.345]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:06.345]                   {
[01:29:06.345]                     inherits <- base::inherits
[01:29:06.345]                     invokeRestart <- base::invokeRestart
[01:29:06.345]                     is.null <- base::is.null
[01:29:06.345]                     muffled <- FALSE
[01:29:06.345]                     if (inherits(cond, "message")) {
[01:29:06.345]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:06.345]                       if (muffled) 
[01:29:06.345]                         invokeRestart("muffleMessage")
[01:29:06.345]                     }
[01:29:06.345]                     else if (inherits(cond, "warning")) {
[01:29:06.345]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:06.345]                       if (muffled) 
[01:29:06.345]                         invokeRestart("muffleWarning")
[01:29:06.345]                     }
[01:29:06.345]                     else if (inherits(cond, "condition")) {
[01:29:06.345]                       if (!is.null(pattern)) {
[01:29:06.345]                         computeRestarts <- base::computeRestarts
[01:29:06.345]                         grepl <- base::grepl
[01:29:06.345]                         restarts <- computeRestarts(cond)
[01:29:06.345]                         for (restart in restarts) {
[01:29:06.345]                           name <- restart$name
[01:29:06.345]                           if (is.null(name)) 
[01:29:06.345]                             next
[01:29:06.345]                           if (!grepl(pattern, name)) 
[01:29:06.345]                             next
[01:29:06.345]                           invokeRestart(restart)
[01:29:06.345]                           muffled <- TRUE
[01:29:06.345]                           break
[01:29:06.345]                         }
[01:29:06.345]                       }
[01:29:06.345]                     }
[01:29:06.345]                     invisible(muffled)
[01:29:06.345]                   }
[01:29:06.345]                   muffleCondition(cond)
[01:29:06.345]                 })
[01:29:06.345]             }))
[01:29:06.345]             future::FutureResult(value = ...future.value$value, 
[01:29:06.345]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:06.345]                   ...future.rng), globalenv = if (FALSE) 
[01:29:06.345]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:06.345]                     ...future.globalenv.names))
[01:29:06.345]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:06.345]         }, condition = base::local({
[01:29:06.345]             c <- base::c
[01:29:06.345]             inherits <- base::inherits
[01:29:06.345]             invokeRestart <- base::invokeRestart
[01:29:06.345]             length <- base::length
[01:29:06.345]             list <- base::list
[01:29:06.345]             seq.int <- base::seq.int
[01:29:06.345]             signalCondition <- base::signalCondition
[01:29:06.345]             sys.calls <- base::sys.calls
[01:29:06.345]             `[[` <- base::`[[`
[01:29:06.345]             `+` <- base::`+`
[01:29:06.345]             `<<-` <- base::`<<-`
[01:29:06.345]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:06.345]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:06.345]                   3L)]
[01:29:06.345]             }
[01:29:06.345]             function(cond) {
[01:29:06.345]                 is_error <- inherits(cond, "error")
[01:29:06.345]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:06.345]                   NULL)
[01:29:06.345]                 if (is_error) {
[01:29:06.345]                   sessionInformation <- function() {
[01:29:06.345]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:06.345]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:06.345]                       search = base::search(), system = base::Sys.info())
[01:29:06.345]                   }
[01:29:06.345]                   ...future.conditions[[length(...future.conditions) + 
[01:29:06.345]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:06.345]                     cond$call), session = sessionInformation(), 
[01:29:06.345]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:06.345]                   signalCondition(cond)
[01:29:06.345]                 }
[01:29:06.345]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:06.345]                 "immediateCondition"))) {
[01:29:06.345]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:06.345]                   ...future.conditions[[length(...future.conditions) + 
[01:29:06.345]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:06.345]                   if (TRUE && !signal) {
[01:29:06.345]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:06.345]                     {
[01:29:06.345]                       inherits <- base::inherits
[01:29:06.345]                       invokeRestart <- base::invokeRestart
[01:29:06.345]                       is.null <- base::is.null
[01:29:06.345]                       muffled <- FALSE
[01:29:06.345]                       if (inherits(cond, "message")) {
[01:29:06.345]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:06.345]                         if (muffled) 
[01:29:06.345]                           invokeRestart("muffleMessage")
[01:29:06.345]                       }
[01:29:06.345]                       else if (inherits(cond, "warning")) {
[01:29:06.345]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:06.345]                         if (muffled) 
[01:29:06.345]                           invokeRestart("muffleWarning")
[01:29:06.345]                       }
[01:29:06.345]                       else if (inherits(cond, "condition")) {
[01:29:06.345]                         if (!is.null(pattern)) {
[01:29:06.345]                           computeRestarts <- base::computeRestarts
[01:29:06.345]                           grepl <- base::grepl
[01:29:06.345]                           restarts <- computeRestarts(cond)
[01:29:06.345]                           for (restart in restarts) {
[01:29:06.345]                             name <- restart$name
[01:29:06.345]                             if (is.null(name)) 
[01:29:06.345]                               next
[01:29:06.345]                             if (!grepl(pattern, name)) 
[01:29:06.345]                               next
[01:29:06.345]                             invokeRestart(restart)
[01:29:06.345]                             muffled <- TRUE
[01:29:06.345]                             break
[01:29:06.345]                           }
[01:29:06.345]                         }
[01:29:06.345]                       }
[01:29:06.345]                       invisible(muffled)
[01:29:06.345]                     }
[01:29:06.345]                     muffleCondition(cond, pattern = "^muffle")
[01:29:06.345]                   }
[01:29:06.345]                 }
[01:29:06.345]                 else {
[01:29:06.345]                   if (TRUE) {
[01:29:06.345]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:06.345]                     {
[01:29:06.345]                       inherits <- base::inherits
[01:29:06.345]                       invokeRestart <- base::invokeRestart
[01:29:06.345]                       is.null <- base::is.null
[01:29:06.345]                       muffled <- FALSE
[01:29:06.345]                       if (inherits(cond, "message")) {
[01:29:06.345]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:06.345]                         if (muffled) 
[01:29:06.345]                           invokeRestart("muffleMessage")
[01:29:06.345]                       }
[01:29:06.345]                       else if (inherits(cond, "warning")) {
[01:29:06.345]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:06.345]                         if (muffled) 
[01:29:06.345]                           invokeRestart("muffleWarning")
[01:29:06.345]                       }
[01:29:06.345]                       else if (inherits(cond, "condition")) {
[01:29:06.345]                         if (!is.null(pattern)) {
[01:29:06.345]                           computeRestarts <- base::computeRestarts
[01:29:06.345]                           grepl <- base::grepl
[01:29:06.345]                           restarts <- computeRestarts(cond)
[01:29:06.345]                           for (restart in restarts) {
[01:29:06.345]                             name <- restart$name
[01:29:06.345]                             if (is.null(name)) 
[01:29:06.345]                               next
[01:29:06.345]                             if (!grepl(pattern, name)) 
[01:29:06.345]                               next
[01:29:06.345]                             invokeRestart(restart)
[01:29:06.345]                             muffled <- TRUE
[01:29:06.345]                             break
[01:29:06.345]                           }
[01:29:06.345]                         }
[01:29:06.345]                       }
[01:29:06.345]                       invisible(muffled)
[01:29:06.345]                     }
[01:29:06.345]                     muffleCondition(cond, pattern = "^muffle")
[01:29:06.345]                   }
[01:29:06.345]                 }
[01:29:06.345]             }
[01:29:06.345]         }))
[01:29:06.345]     }, error = function(ex) {
[01:29:06.345]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:06.345]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:06.345]                 ...future.rng), started = ...future.startTime, 
[01:29:06.345]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:06.345]             version = "1.8"), class = "FutureResult")
[01:29:06.345]     }, finally = {
[01:29:06.345]         if (!identical(...future.workdir, getwd())) 
[01:29:06.345]             setwd(...future.workdir)
[01:29:06.345]         {
[01:29:06.345]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:06.345]                 ...future.oldOptions$nwarnings <- NULL
[01:29:06.345]             }
[01:29:06.345]             base::options(...future.oldOptions)
[01:29:06.345]             if (.Platform$OS.type == "windows") {
[01:29:06.345]                 old_names <- names(...future.oldEnvVars)
[01:29:06.345]                 envs <- base::Sys.getenv()
[01:29:06.345]                 names <- names(envs)
[01:29:06.345]                 common <- intersect(names, old_names)
[01:29:06.345]                 added <- setdiff(names, old_names)
[01:29:06.345]                 removed <- setdiff(old_names, names)
[01:29:06.345]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:06.345]                   envs[common]]
[01:29:06.345]                 NAMES <- toupper(changed)
[01:29:06.345]                 args <- list()
[01:29:06.345]                 for (kk in seq_along(NAMES)) {
[01:29:06.345]                   name <- changed[[kk]]
[01:29:06.345]                   NAME <- NAMES[[kk]]
[01:29:06.345]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:06.345]                     next
[01:29:06.345]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:06.345]                 }
[01:29:06.345]                 NAMES <- toupper(added)
[01:29:06.345]                 for (kk in seq_along(NAMES)) {
[01:29:06.345]                   name <- added[[kk]]
[01:29:06.345]                   NAME <- NAMES[[kk]]
[01:29:06.345]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:06.345]                     next
[01:29:06.345]                   args[[name]] <- ""
[01:29:06.345]                 }
[01:29:06.345]                 NAMES <- toupper(removed)
[01:29:06.345]                 for (kk in seq_along(NAMES)) {
[01:29:06.345]                   name <- removed[[kk]]
[01:29:06.345]                   NAME <- NAMES[[kk]]
[01:29:06.345]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:06.345]                     next
[01:29:06.345]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:06.345]                 }
[01:29:06.345]                 if (length(args) > 0) 
[01:29:06.345]                   base::do.call(base::Sys.setenv, args = args)
[01:29:06.345]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:06.345]             }
[01:29:06.345]             else {
[01:29:06.345]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:06.345]             }
[01:29:06.345]             {
[01:29:06.345]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:06.345]                   0L) {
[01:29:06.345]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:06.345]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:06.345]                   base::options(opts)
[01:29:06.345]                 }
[01:29:06.345]                 {
[01:29:06.345]                   {
[01:29:06.345]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:06.345]                     NULL
[01:29:06.345]                   }
[01:29:06.345]                   options(future.plan = NULL)
[01:29:06.345]                   if (is.na(NA_character_)) 
[01:29:06.345]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:06.345]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:06.345]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:06.345]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:06.345]                     envir = parent.frame()) 
[01:29:06.345]                   {
[01:29:06.345]                     if (is.function(workers)) 
[01:29:06.345]                       workers <- workers()
[01:29:06.345]                     workers <- structure(as.integer(workers), 
[01:29:06.345]                       class = class(workers))
[01:29:06.345]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:06.345]                       workers >= 1)
[01:29:06.345]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:06.345]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:06.345]                     }
[01:29:06.345]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:06.345]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:06.345]                       envir = envir)
[01:29:06.345]                     if (!future$lazy) 
[01:29:06.345]                       future <- run(future)
[01:29:06.345]                     invisible(future)
[01:29:06.345]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:06.345]                 }
[01:29:06.345]             }
[01:29:06.345]         }
[01:29:06.345]     })
[01:29:06.345]     if (TRUE) {
[01:29:06.345]         base::sink(type = "output", split = FALSE)
[01:29:06.345]         if (TRUE) {
[01:29:06.345]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:06.345]         }
[01:29:06.345]         else {
[01:29:06.345]             ...future.result["stdout"] <- base::list(NULL)
[01:29:06.345]         }
[01:29:06.345]         base::close(...future.stdout)
[01:29:06.345]         ...future.stdout <- NULL
[01:29:06.345]     }
[01:29:06.345]     ...future.result$conditions <- ...future.conditions
[01:29:06.345]     ...future.result$finished <- base::Sys.time()
[01:29:06.345]     ...future.result
[01:29:06.345] }
[01:29:06.351] MultisessionFuture started
[01:29:06.351] - Launch lazy future ... done
[01:29:06.351] run() for 'MultisessionFuture' ... done
[01:29:06.370] receiveMessageFromWorker() for ClusterFuture ...
[01:29:06.370] - Validating connection of MultisessionFuture
[01:29:06.371] - received message: FutureResult
[01:29:06.371] - Received FutureResult
[01:29:06.371] - Erased future from FutureRegistry
[01:29:06.372] result() for ClusterFuture ...
[01:29:06.372] - result already collected: FutureResult
[01:29:06.372] result() for ClusterFuture ... done
[01:29:06.372] signalConditions() ...
[01:29:06.372]  - include = 'immediateCondition'
[01:29:06.373]  - exclude = 
[01:29:06.373]  - resignal = FALSE
[01:29:06.373]  - Number of conditions: 1
[01:29:06.373] signalConditions() ... done
[01:29:06.373] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:06.373] A MultisessionFuture was resolved (and resolved itself)
- result = TRUE, recursive = TRUE ... DONE
- result = TRUE, recursive = -1 ...
[01:29:06.374] getGlobalsAndPackages() ...
[01:29:06.374] Searching for globals...
[01:29:06.375] - globals found: [3] '{', 'Sys.sleep', 'list'
[01:29:06.376] Searching for globals ... DONE
[01:29:06.376] Resolving globals: FALSE
[01:29:06.376] 
[01:29:06.376] 
[01:29:06.376] getGlobalsAndPackages() ... DONE
[01:29:06.377] run() for 'Future' ...
[01:29:06.377] - state: 'created'
[01:29:06.377] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:06.391] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:06.391] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:06.392]   - Field: 'node'
[01:29:06.392]   - Field: 'label'
[01:29:06.392]   - Field: 'local'
[01:29:06.392]   - Field: 'owner'
[01:29:06.392]   - Field: 'envir'
[01:29:06.392]   - Field: 'workers'
[01:29:06.393]   - Field: 'packages'
[01:29:06.393]   - Field: 'gc'
[01:29:06.393]   - Field: 'conditions'
[01:29:06.393]   - Field: 'persistent'
[01:29:06.393]   - Field: 'expr'
[01:29:06.394]   - Field: 'uuid'
[01:29:06.394]   - Field: 'seed'
[01:29:06.394]   - Field: 'version'
[01:29:06.394]   - Field: 'result'
[01:29:06.394]   - Field: 'asynchronous'
[01:29:06.394]   - Field: 'calls'
[01:29:06.395]   - Field: 'globals'
[01:29:06.395]   - Field: 'stdout'
[01:29:06.395]   - Field: 'earlySignal'
[01:29:06.395]   - Field: 'lazy'
[01:29:06.395]   - Field: 'state'
[01:29:06.395] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:06.396] - Launch lazy future ...
[01:29:06.396] Packages needed by the future expression (n = 0): <none>
[01:29:06.396] Packages needed by future strategies (n = 0): <none>
[01:29:06.397] {
[01:29:06.397]     {
[01:29:06.397]         {
[01:29:06.397]             ...future.startTime <- base::Sys.time()
[01:29:06.397]             {
[01:29:06.397]                 {
[01:29:06.397]                   {
[01:29:06.397]                     {
[01:29:06.397]                       base::local({
[01:29:06.397]                         has_future <- base::requireNamespace("future", 
[01:29:06.397]                           quietly = TRUE)
[01:29:06.397]                         if (has_future) {
[01:29:06.397]                           ns <- base::getNamespace("future")
[01:29:06.397]                           version <- ns[[".package"]][["version"]]
[01:29:06.397]                           if (is.null(version)) 
[01:29:06.397]                             version <- utils::packageVersion("future")
[01:29:06.397]                         }
[01:29:06.397]                         else {
[01:29:06.397]                           version <- NULL
[01:29:06.397]                         }
[01:29:06.397]                         if (!has_future || version < "1.8.0") {
[01:29:06.397]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:06.397]                             "", base::R.version$version.string), 
[01:29:06.397]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:06.397]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:06.397]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:06.397]                               "release", "version")], collapse = " "), 
[01:29:06.397]                             hostname = base::Sys.info()[["nodename"]])
[01:29:06.397]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:06.397]                             info)
[01:29:06.397]                           info <- base::paste(info, collapse = "; ")
[01:29:06.397]                           if (!has_future) {
[01:29:06.397]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:06.397]                               info)
[01:29:06.397]                           }
[01:29:06.397]                           else {
[01:29:06.397]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:06.397]                               info, version)
[01:29:06.397]                           }
[01:29:06.397]                           base::stop(msg)
[01:29:06.397]                         }
[01:29:06.397]                       })
[01:29:06.397]                     }
[01:29:06.397]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:06.397]                     base::options(mc.cores = 1L)
[01:29:06.397]                   }
[01:29:06.397]                   options(future.plan = NULL)
[01:29:06.397]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:06.397]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:06.397]                 }
[01:29:06.397]                 ...future.workdir <- getwd()
[01:29:06.397]             }
[01:29:06.397]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:06.397]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:06.397]         }
[01:29:06.397]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:06.397]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:06.397]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:06.397]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:06.397]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:06.397]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:06.397]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:06.397]             base::names(...future.oldOptions))
[01:29:06.397]     }
[01:29:06.397]     if (FALSE) {
[01:29:06.397]     }
[01:29:06.397]     else {
[01:29:06.397]         if (TRUE) {
[01:29:06.397]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:06.397]                 open = "w")
[01:29:06.397]         }
[01:29:06.397]         else {
[01:29:06.397]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:06.397]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:06.397]         }
[01:29:06.397]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:06.397]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:06.397]             base::sink(type = "output", split = FALSE)
[01:29:06.397]             base::close(...future.stdout)
[01:29:06.397]         }, add = TRUE)
[01:29:06.397]     }
[01:29:06.397]     ...future.frame <- base::sys.nframe()
[01:29:06.397]     ...future.conditions <- base::list()
[01:29:06.397]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:06.397]     if (FALSE) {
[01:29:06.397]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:06.397]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:06.397]     }
[01:29:06.397]     ...future.result <- base::tryCatch({
[01:29:06.397]         base::withCallingHandlers({
[01:29:06.397]             ...future.value <- base::withVisible(base::local({
[01:29:06.397]                 ...future.makeSendCondition <- base::local({
[01:29:06.397]                   sendCondition <- NULL
[01:29:06.397]                   function(frame = 1L) {
[01:29:06.397]                     if (is.function(sendCondition)) 
[01:29:06.397]                       return(sendCondition)
[01:29:06.397]                     ns <- getNamespace("parallel")
[01:29:06.397]                     if (exists("sendData", mode = "function", 
[01:29:06.397]                       envir = ns)) {
[01:29:06.397]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:06.397]                         envir = ns)
[01:29:06.397]                       envir <- sys.frame(frame)
[01:29:06.397]                       master <- NULL
[01:29:06.397]                       while (!identical(envir, .GlobalEnv) && 
[01:29:06.397]                         !identical(envir, emptyenv())) {
[01:29:06.397]                         if (exists("master", mode = "list", envir = envir, 
[01:29:06.397]                           inherits = FALSE)) {
[01:29:06.397]                           master <- get("master", mode = "list", 
[01:29:06.397]                             envir = envir, inherits = FALSE)
[01:29:06.397]                           if (inherits(master, c("SOCKnode", 
[01:29:06.397]                             "SOCK0node"))) {
[01:29:06.397]                             sendCondition <<- function(cond) {
[01:29:06.397]                               data <- list(type = "VALUE", value = cond, 
[01:29:06.397]                                 success = TRUE)
[01:29:06.397]                               parallel_sendData(master, data)
[01:29:06.397]                             }
[01:29:06.397]                             return(sendCondition)
[01:29:06.397]                           }
[01:29:06.397]                         }
[01:29:06.397]                         frame <- frame + 1L
[01:29:06.397]                         envir <- sys.frame(frame)
[01:29:06.397]                       }
[01:29:06.397]                     }
[01:29:06.397]                     sendCondition <<- function(cond) NULL
[01:29:06.397]                   }
[01:29:06.397]                 })
[01:29:06.397]                 withCallingHandlers({
[01:29:06.397]                   {
[01:29:06.397]                     Sys.sleep(0.5)
[01:29:06.397]                     list(a = 1, b = 42L)
[01:29:06.397]                   }
[01:29:06.397]                 }, immediateCondition = function(cond) {
[01:29:06.397]                   sendCondition <- ...future.makeSendCondition()
[01:29:06.397]                   sendCondition(cond)
[01:29:06.397]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:06.397]                   {
[01:29:06.397]                     inherits <- base::inherits
[01:29:06.397]                     invokeRestart <- base::invokeRestart
[01:29:06.397]                     is.null <- base::is.null
[01:29:06.397]                     muffled <- FALSE
[01:29:06.397]                     if (inherits(cond, "message")) {
[01:29:06.397]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:06.397]                       if (muffled) 
[01:29:06.397]                         invokeRestart("muffleMessage")
[01:29:06.397]                     }
[01:29:06.397]                     else if (inherits(cond, "warning")) {
[01:29:06.397]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:06.397]                       if (muffled) 
[01:29:06.397]                         invokeRestart("muffleWarning")
[01:29:06.397]                     }
[01:29:06.397]                     else if (inherits(cond, "condition")) {
[01:29:06.397]                       if (!is.null(pattern)) {
[01:29:06.397]                         computeRestarts <- base::computeRestarts
[01:29:06.397]                         grepl <- base::grepl
[01:29:06.397]                         restarts <- computeRestarts(cond)
[01:29:06.397]                         for (restart in restarts) {
[01:29:06.397]                           name <- restart$name
[01:29:06.397]                           if (is.null(name)) 
[01:29:06.397]                             next
[01:29:06.397]                           if (!grepl(pattern, name)) 
[01:29:06.397]                             next
[01:29:06.397]                           invokeRestart(restart)
[01:29:06.397]                           muffled <- TRUE
[01:29:06.397]                           break
[01:29:06.397]                         }
[01:29:06.397]                       }
[01:29:06.397]                     }
[01:29:06.397]                     invisible(muffled)
[01:29:06.397]                   }
[01:29:06.397]                   muffleCondition(cond)
[01:29:06.397]                 })
[01:29:06.397]             }))
[01:29:06.397]             future::FutureResult(value = ...future.value$value, 
[01:29:06.397]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:06.397]                   ...future.rng), globalenv = if (FALSE) 
[01:29:06.397]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:06.397]                     ...future.globalenv.names))
[01:29:06.397]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:06.397]         }, condition = base::local({
[01:29:06.397]             c <- base::c
[01:29:06.397]             inherits <- base::inherits
[01:29:06.397]             invokeRestart <- base::invokeRestart
[01:29:06.397]             length <- base::length
[01:29:06.397]             list <- base::list
[01:29:06.397]             seq.int <- base::seq.int
[01:29:06.397]             signalCondition <- base::signalCondition
[01:29:06.397]             sys.calls <- base::sys.calls
[01:29:06.397]             `[[` <- base::`[[`
[01:29:06.397]             `+` <- base::`+`
[01:29:06.397]             `<<-` <- base::`<<-`
[01:29:06.397]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:06.397]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:06.397]                   3L)]
[01:29:06.397]             }
[01:29:06.397]             function(cond) {
[01:29:06.397]                 is_error <- inherits(cond, "error")
[01:29:06.397]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:06.397]                   NULL)
[01:29:06.397]                 if (is_error) {
[01:29:06.397]                   sessionInformation <- function() {
[01:29:06.397]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:06.397]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:06.397]                       search = base::search(), system = base::Sys.info())
[01:29:06.397]                   }
[01:29:06.397]                   ...future.conditions[[length(...future.conditions) + 
[01:29:06.397]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:06.397]                     cond$call), session = sessionInformation(), 
[01:29:06.397]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:06.397]                   signalCondition(cond)
[01:29:06.397]                 }
[01:29:06.397]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:06.397]                 "immediateCondition"))) {
[01:29:06.397]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:06.397]                   ...future.conditions[[length(...future.conditions) + 
[01:29:06.397]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:06.397]                   if (TRUE && !signal) {
[01:29:06.397]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:06.397]                     {
[01:29:06.397]                       inherits <- base::inherits
[01:29:06.397]                       invokeRestart <- base::invokeRestart
[01:29:06.397]                       is.null <- base::is.null
[01:29:06.397]                       muffled <- FALSE
[01:29:06.397]                       if (inherits(cond, "message")) {
[01:29:06.397]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:06.397]                         if (muffled) 
[01:29:06.397]                           invokeRestart("muffleMessage")
[01:29:06.397]                       }
[01:29:06.397]                       else if (inherits(cond, "warning")) {
[01:29:06.397]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:06.397]                         if (muffled) 
[01:29:06.397]                           invokeRestart("muffleWarning")
[01:29:06.397]                       }
[01:29:06.397]                       else if (inherits(cond, "condition")) {
[01:29:06.397]                         if (!is.null(pattern)) {
[01:29:06.397]                           computeRestarts <- base::computeRestarts
[01:29:06.397]                           grepl <- base::grepl
[01:29:06.397]                           restarts <- computeRestarts(cond)
[01:29:06.397]                           for (restart in restarts) {
[01:29:06.397]                             name <- restart$name
[01:29:06.397]                             if (is.null(name)) 
[01:29:06.397]                               next
[01:29:06.397]                             if (!grepl(pattern, name)) 
[01:29:06.397]                               next
[01:29:06.397]                             invokeRestart(restart)
[01:29:06.397]                             muffled <- TRUE
[01:29:06.397]                             break
[01:29:06.397]                           }
[01:29:06.397]                         }
[01:29:06.397]                       }
[01:29:06.397]                       invisible(muffled)
[01:29:06.397]                     }
[01:29:06.397]                     muffleCondition(cond, pattern = "^muffle")
[01:29:06.397]                   }
[01:29:06.397]                 }
[01:29:06.397]                 else {
[01:29:06.397]                   if (TRUE) {
[01:29:06.397]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:06.397]                     {
[01:29:06.397]                       inherits <- base::inherits
[01:29:06.397]                       invokeRestart <- base::invokeRestart
[01:29:06.397]                       is.null <- base::is.null
[01:29:06.397]                       muffled <- FALSE
[01:29:06.397]                       if (inherits(cond, "message")) {
[01:29:06.397]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:06.397]                         if (muffled) 
[01:29:06.397]                           invokeRestart("muffleMessage")
[01:29:06.397]                       }
[01:29:06.397]                       else if (inherits(cond, "warning")) {
[01:29:06.397]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:06.397]                         if (muffled) 
[01:29:06.397]                           invokeRestart("muffleWarning")
[01:29:06.397]                       }
[01:29:06.397]                       else if (inherits(cond, "condition")) {
[01:29:06.397]                         if (!is.null(pattern)) {
[01:29:06.397]                           computeRestarts <- base::computeRestarts
[01:29:06.397]                           grepl <- base::grepl
[01:29:06.397]                           restarts <- computeRestarts(cond)
[01:29:06.397]                           for (restart in restarts) {
[01:29:06.397]                             name <- restart$name
[01:29:06.397]                             if (is.null(name)) 
[01:29:06.397]                               next
[01:29:06.397]                             if (!grepl(pattern, name)) 
[01:29:06.397]                               next
[01:29:06.397]                             invokeRestart(restart)
[01:29:06.397]                             muffled <- TRUE
[01:29:06.397]                             break
[01:29:06.397]                           }
[01:29:06.397]                         }
[01:29:06.397]                       }
[01:29:06.397]                       invisible(muffled)
[01:29:06.397]                     }
[01:29:06.397]                     muffleCondition(cond, pattern = "^muffle")
[01:29:06.397]                   }
[01:29:06.397]                 }
[01:29:06.397]             }
[01:29:06.397]         }))
[01:29:06.397]     }, error = function(ex) {
[01:29:06.397]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:06.397]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:06.397]                 ...future.rng), started = ...future.startTime, 
[01:29:06.397]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:06.397]             version = "1.8"), class = "FutureResult")
[01:29:06.397]     }, finally = {
[01:29:06.397]         if (!identical(...future.workdir, getwd())) 
[01:29:06.397]             setwd(...future.workdir)
[01:29:06.397]         {
[01:29:06.397]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:06.397]                 ...future.oldOptions$nwarnings <- NULL
[01:29:06.397]             }
[01:29:06.397]             base::options(...future.oldOptions)
[01:29:06.397]             if (.Platform$OS.type == "windows") {
[01:29:06.397]                 old_names <- names(...future.oldEnvVars)
[01:29:06.397]                 envs <- base::Sys.getenv()
[01:29:06.397]                 names <- names(envs)
[01:29:06.397]                 common <- intersect(names, old_names)
[01:29:06.397]                 added <- setdiff(names, old_names)
[01:29:06.397]                 removed <- setdiff(old_names, names)
[01:29:06.397]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:06.397]                   envs[common]]
[01:29:06.397]                 NAMES <- toupper(changed)
[01:29:06.397]                 args <- list()
[01:29:06.397]                 for (kk in seq_along(NAMES)) {
[01:29:06.397]                   name <- changed[[kk]]
[01:29:06.397]                   NAME <- NAMES[[kk]]
[01:29:06.397]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:06.397]                     next
[01:29:06.397]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:06.397]                 }
[01:29:06.397]                 NAMES <- toupper(added)
[01:29:06.397]                 for (kk in seq_along(NAMES)) {
[01:29:06.397]                   name <- added[[kk]]
[01:29:06.397]                   NAME <- NAMES[[kk]]
[01:29:06.397]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:06.397]                     next
[01:29:06.397]                   args[[name]] <- ""
[01:29:06.397]                 }
[01:29:06.397]                 NAMES <- toupper(removed)
[01:29:06.397]                 for (kk in seq_along(NAMES)) {
[01:29:06.397]                   name <- removed[[kk]]
[01:29:06.397]                   NAME <- NAMES[[kk]]
[01:29:06.397]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:06.397]                     next
[01:29:06.397]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:06.397]                 }
[01:29:06.397]                 if (length(args) > 0) 
[01:29:06.397]                   base::do.call(base::Sys.setenv, args = args)
[01:29:06.397]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:06.397]             }
[01:29:06.397]             else {
[01:29:06.397]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:06.397]             }
[01:29:06.397]             {
[01:29:06.397]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:06.397]                   0L) {
[01:29:06.397]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:06.397]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:06.397]                   base::options(opts)
[01:29:06.397]                 }
[01:29:06.397]                 {
[01:29:06.397]                   {
[01:29:06.397]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:06.397]                     NULL
[01:29:06.397]                   }
[01:29:06.397]                   options(future.plan = NULL)
[01:29:06.397]                   if (is.na(NA_character_)) 
[01:29:06.397]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:06.397]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:06.397]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:06.397]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:06.397]                     envir = parent.frame()) 
[01:29:06.397]                   {
[01:29:06.397]                     if (is.function(workers)) 
[01:29:06.397]                       workers <- workers()
[01:29:06.397]                     workers <- structure(as.integer(workers), 
[01:29:06.397]                       class = class(workers))
[01:29:06.397]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:06.397]                       workers >= 1)
[01:29:06.397]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:06.397]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:06.397]                     }
[01:29:06.397]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:06.397]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:06.397]                       envir = envir)
[01:29:06.397]                     if (!future$lazy) 
[01:29:06.397]                       future <- run(future)
[01:29:06.397]                     invisible(future)
[01:29:06.397]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:06.397]                 }
[01:29:06.397]             }
[01:29:06.397]         }
[01:29:06.397]     })
[01:29:06.397]     if (TRUE) {
[01:29:06.397]         base::sink(type = "output", split = FALSE)
[01:29:06.397]         if (TRUE) {
[01:29:06.397]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:06.397]         }
[01:29:06.397]         else {
[01:29:06.397]             ...future.result["stdout"] <- base::list(NULL)
[01:29:06.397]         }
[01:29:06.397]         base::close(...future.stdout)
[01:29:06.397]         ...future.stdout <- NULL
[01:29:06.397]     }
[01:29:06.397]     ...future.result$conditions <- ...future.conditions
[01:29:06.397]     ...future.result$finished <- base::Sys.time()
[01:29:06.397]     ...future.result
[01:29:06.397] }
[01:29:06.403] MultisessionFuture started
[01:29:06.403] - Launch lazy future ... done
[01:29:06.403] run() for 'MultisessionFuture' ... done
[01:29:06.403] getGlobalsAndPackages() ...
[01:29:06.403] Searching for globals...
[01:29:06.407] - globals found: [3] '{', 'Sys.sleep', 'list'
[01:29:06.407] Searching for globals ... DONE
[01:29:06.408] Resolving globals: FALSE
[01:29:06.408] 
[01:29:06.408] 
[01:29:06.408] getGlobalsAndPackages() ... DONE
- w/ exception ...
[01:29:06.409] getGlobalsAndPackages() ...
[01:29:06.409] Searching for globals...
[01:29:06.410] - globals found: [2] 'list', 'stop'
[01:29:06.410] Searching for globals ... DONE
[01:29:06.410] Resolving globals: FALSE
[01:29:06.410] 
[01:29:06.410] 
[01:29:06.411] getGlobalsAndPackages() ... DONE
[01:29:06.411] run() for 'Future' ...
[01:29:06.411] - state: 'created'
[01:29:06.411] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:06.425] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:06.426] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:06.426]   - Field: 'node'
[01:29:06.426]   - Field: 'label'
[01:29:06.426]   - Field: 'local'
[01:29:06.426]   - Field: 'owner'
[01:29:06.427]   - Field: 'envir'
[01:29:06.427]   - Field: 'workers'
[01:29:06.427]   - Field: 'packages'
[01:29:06.427]   - Field: 'gc'
[01:29:06.427]   - Field: 'conditions'
[01:29:06.428]   - Field: 'persistent'
[01:29:06.428]   - Field: 'expr'
[01:29:06.428]   - Field: 'uuid'
[01:29:06.428]   - Field: 'seed'
[01:29:06.428]   - Field: 'version'
[01:29:06.428]   - Field: 'result'
[01:29:06.429]   - Field: 'asynchronous'
[01:29:06.429]   - Field: 'calls'
[01:29:06.429]   - Field: 'globals'
[01:29:06.429]   - Field: 'stdout'
[01:29:06.429]   - Field: 'earlySignal'
[01:29:06.429]   - Field: 'lazy'
[01:29:06.430]   - Field: 'state'
[01:29:06.430] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:06.430] - Launch lazy future ...
[01:29:06.430] Packages needed by the future expression (n = 0): <none>
[01:29:06.430] Packages needed by future strategies (n = 0): <none>
[01:29:06.431] {
[01:29:06.431]     {
[01:29:06.431]         {
[01:29:06.431]             ...future.startTime <- base::Sys.time()
[01:29:06.431]             {
[01:29:06.431]                 {
[01:29:06.431]                   {
[01:29:06.431]                     {
[01:29:06.431]                       base::local({
[01:29:06.431]                         has_future <- base::requireNamespace("future", 
[01:29:06.431]                           quietly = TRUE)
[01:29:06.431]                         if (has_future) {
[01:29:06.431]                           ns <- base::getNamespace("future")
[01:29:06.431]                           version <- ns[[".package"]][["version"]]
[01:29:06.431]                           if (is.null(version)) 
[01:29:06.431]                             version <- utils::packageVersion("future")
[01:29:06.431]                         }
[01:29:06.431]                         else {
[01:29:06.431]                           version <- NULL
[01:29:06.431]                         }
[01:29:06.431]                         if (!has_future || version < "1.8.0") {
[01:29:06.431]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:06.431]                             "", base::R.version$version.string), 
[01:29:06.431]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:06.431]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:06.431]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:06.431]                               "release", "version")], collapse = " "), 
[01:29:06.431]                             hostname = base::Sys.info()[["nodename"]])
[01:29:06.431]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:06.431]                             info)
[01:29:06.431]                           info <- base::paste(info, collapse = "; ")
[01:29:06.431]                           if (!has_future) {
[01:29:06.431]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:06.431]                               info)
[01:29:06.431]                           }
[01:29:06.431]                           else {
[01:29:06.431]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:06.431]                               info, version)
[01:29:06.431]                           }
[01:29:06.431]                           base::stop(msg)
[01:29:06.431]                         }
[01:29:06.431]                       })
[01:29:06.431]                     }
[01:29:06.431]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:06.431]                     base::options(mc.cores = 1L)
[01:29:06.431]                   }
[01:29:06.431]                   options(future.plan = NULL)
[01:29:06.431]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:06.431]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:06.431]                 }
[01:29:06.431]                 ...future.workdir <- getwd()
[01:29:06.431]             }
[01:29:06.431]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:06.431]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:06.431]         }
[01:29:06.431]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:06.431]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:06.431]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:06.431]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:06.431]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:06.431]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:06.431]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:06.431]             base::names(...future.oldOptions))
[01:29:06.431]     }
[01:29:06.431]     if (FALSE) {
[01:29:06.431]     }
[01:29:06.431]     else {
[01:29:06.431]         if (TRUE) {
[01:29:06.431]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:06.431]                 open = "w")
[01:29:06.431]         }
[01:29:06.431]         else {
[01:29:06.431]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:06.431]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:06.431]         }
[01:29:06.431]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:06.431]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:06.431]             base::sink(type = "output", split = FALSE)
[01:29:06.431]             base::close(...future.stdout)
[01:29:06.431]         }, add = TRUE)
[01:29:06.431]     }
[01:29:06.431]     ...future.frame <- base::sys.nframe()
[01:29:06.431]     ...future.conditions <- base::list()
[01:29:06.431]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:06.431]     if (FALSE) {
[01:29:06.431]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:06.431]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:06.431]     }
[01:29:06.431]     ...future.result <- base::tryCatch({
[01:29:06.431]         base::withCallingHandlers({
[01:29:06.431]             ...future.value <- base::withVisible(base::local({
[01:29:06.431]                 ...future.makeSendCondition <- base::local({
[01:29:06.431]                   sendCondition <- NULL
[01:29:06.431]                   function(frame = 1L) {
[01:29:06.431]                     if (is.function(sendCondition)) 
[01:29:06.431]                       return(sendCondition)
[01:29:06.431]                     ns <- getNamespace("parallel")
[01:29:06.431]                     if (exists("sendData", mode = "function", 
[01:29:06.431]                       envir = ns)) {
[01:29:06.431]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:06.431]                         envir = ns)
[01:29:06.431]                       envir <- sys.frame(frame)
[01:29:06.431]                       master <- NULL
[01:29:06.431]                       while (!identical(envir, .GlobalEnv) && 
[01:29:06.431]                         !identical(envir, emptyenv())) {
[01:29:06.431]                         if (exists("master", mode = "list", envir = envir, 
[01:29:06.431]                           inherits = FALSE)) {
[01:29:06.431]                           master <- get("master", mode = "list", 
[01:29:06.431]                             envir = envir, inherits = FALSE)
[01:29:06.431]                           if (inherits(master, c("SOCKnode", 
[01:29:06.431]                             "SOCK0node"))) {
[01:29:06.431]                             sendCondition <<- function(cond) {
[01:29:06.431]                               data <- list(type = "VALUE", value = cond, 
[01:29:06.431]                                 success = TRUE)
[01:29:06.431]                               parallel_sendData(master, data)
[01:29:06.431]                             }
[01:29:06.431]                             return(sendCondition)
[01:29:06.431]                           }
[01:29:06.431]                         }
[01:29:06.431]                         frame <- frame + 1L
[01:29:06.431]                         envir <- sys.frame(frame)
[01:29:06.431]                       }
[01:29:06.431]                     }
[01:29:06.431]                     sendCondition <<- function(cond) NULL
[01:29:06.431]                   }
[01:29:06.431]                 })
[01:29:06.431]                 withCallingHandlers({
[01:29:06.431]                   list(a = 1, b = 42L, c = stop("Nah!"))
[01:29:06.431]                 }, immediateCondition = function(cond) {
[01:29:06.431]                   sendCondition <- ...future.makeSendCondition()
[01:29:06.431]                   sendCondition(cond)
[01:29:06.431]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:06.431]                   {
[01:29:06.431]                     inherits <- base::inherits
[01:29:06.431]                     invokeRestart <- base::invokeRestart
[01:29:06.431]                     is.null <- base::is.null
[01:29:06.431]                     muffled <- FALSE
[01:29:06.431]                     if (inherits(cond, "message")) {
[01:29:06.431]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:06.431]                       if (muffled) 
[01:29:06.431]                         invokeRestart("muffleMessage")
[01:29:06.431]                     }
[01:29:06.431]                     else if (inherits(cond, "warning")) {
[01:29:06.431]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:06.431]                       if (muffled) 
[01:29:06.431]                         invokeRestart("muffleWarning")
[01:29:06.431]                     }
[01:29:06.431]                     else if (inherits(cond, "condition")) {
[01:29:06.431]                       if (!is.null(pattern)) {
[01:29:06.431]                         computeRestarts <- base::computeRestarts
[01:29:06.431]                         grepl <- base::grepl
[01:29:06.431]                         restarts <- computeRestarts(cond)
[01:29:06.431]                         for (restart in restarts) {
[01:29:06.431]                           name <- restart$name
[01:29:06.431]                           if (is.null(name)) 
[01:29:06.431]                             next
[01:29:06.431]                           if (!grepl(pattern, name)) 
[01:29:06.431]                             next
[01:29:06.431]                           invokeRestart(restart)
[01:29:06.431]                           muffled <- TRUE
[01:29:06.431]                           break
[01:29:06.431]                         }
[01:29:06.431]                       }
[01:29:06.431]                     }
[01:29:06.431]                     invisible(muffled)
[01:29:06.431]                   }
[01:29:06.431]                   muffleCondition(cond)
[01:29:06.431]                 })
[01:29:06.431]             }))
[01:29:06.431]             future::FutureResult(value = ...future.value$value, 
[01:29:06.431]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:06.431]                   ...future.rng), globalenv = if (FALSE) 
[01:29:06.431]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:06.431]                     ...future.globalenv.names))
[01:29:06.431]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:06.431]         }, condition = base::local({
[01:29:06.431]             c <- base::c
[01:29:06.431]             inherits <- base::inherits
[01:29:06.431]             invokeRestart <- base::invokeRestart
[01:29:06.431]             length <- base::length
[01:29:06.431]             list <- base::list
[01:29:06.431]             seq.int <- base::seq.int
[01:29:06.431]             signalCondition <- base::signalCondition
[01:29:06.431]             sys.calls <- base::sys.calls
[01:29:06.431]             `[[` <- base::`[[`
[01:29:06.431]             `+` <- base::`+`
[01:29:06.431]             `<<-` <- base::`<<-`
[01:29:06.431]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:06.431]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:06.431]                   3L)]
[01:29:06.431]             }
[01:29:06.431]             function(cond) {
[01:29:06.431]                 is_error <- inherits(cond, "error")
[01:29:06.431]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:06.431]                   NULL)
[01:29:06.431]                 if (is_error) {
[01:29:06.431]                   sessionInformation <- function() {
[01:29:06.431]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:06.431]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:06.431]                       search = base::search(), system = base::Sys.info())
[01:29:06.431]                   }
[01:29:06.431]                   ...future.conditions[[length(...future.conditions) + 
[01:29:06.431]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:06.431]                     cond$call), session = sessionInformation(), 
[01:29:06.431]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:06.431]                   signalCondition(cond)
[01:29:06.431]                 }
[01:29:06.431]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:06.431]                 "immediateCondition"))) {
[01:29:06.431]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:06.431]                   ...future.conditions[[length(...future.conditions) + 
[01:29:06.431]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:06.431]                   if (TRUE && !signal) {
[01:29:06.431]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:06.431]                     {
[01:29:06.431]                       inherits <- base::inherits
[01:29:06.431]                       invokeRestart <- base::invokeRestart
[01:29:06.431]                       is.null <- base::is.null
[01:29:06.431]                       muffled <- FALSE
[01:29:06.431]                       if (inherits(cond, "message")) {
[01:29:06.431]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:06.431]                         if (muffled) 
[01:29:06.431]                           invokeRestart("muffleMessage")
[01:29:06.431]                       }
[01:29:06.431]                       else if (inherits(cond, "warning")) {
[01:29:06.431]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:06.431]                         if (muffled) 
[01:29:06.431]                           invokeRestart("muffleWarning")
[01:29:06.431]                       }
[01:29:06.431]                       else if (inherits(cond, "condition")) {
[01:29:06.431]                         if (!is.null(pattern)) {
[01:29:06.431]                           computeRestarts <- base::computeRestarts
[01:29:06.431]                           grepl <- base::grepl
[01:29:06.431]                           restarts <- computeRestarts(cond)
[01:29:06.431]                           for (restart in restarts) {
[01:29:06.431]                             name <- restart$name
[01:29:06.431]                             if (is.null(name)) 
[01:29:06.431]                               next
[01:29:06.431]                             if (!grepl(pattern, name)) 
[01:29:06.431]                               next
[01:29:06.431]                             invokeRestart(restart)
[01:29:06.431]                             muffled <- TRUE
[01:29:06.431]                             break
[01:29:06.431]                           }
[01:29:06.431]                         }
[01:29:06.431]                       }
[01:29:06.431]                       invisible(muffled)
[01:29:06.431]                     }
[01:29:06.431]                     muffleCondition(cond, pattern = "^muffle")
[01:29:06.431]                   }
[01:29:06.431]                 }
[01:29:06.431]                 else {
[01:29:06.431]                   if (TRUE) {
[01:29:06.431]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:06.431]                     {
[01:29:06.431]                       inherits <- base::inherits
[01:29:06.431]                       invokeRestart <- base::invokeRestart
[01:29:06.431]                       is.null <- base::is.null
[01:29:06.431]                       muffled <- FALSE
[01:29:06.431]                       if (inherits(cond, "message")) {
[01:29:06.431]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:06.431]                         if (muffled) 
[01:29:06.431]                           invokeRestart("muffleMessage")
[01:29:06.431]                       }
[01:29:06.431]                       else if (inherits(cond, "warning")) {
[01:29:06.431]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:06.431]                         if (muffled) 
[01:29:06.431]                           invokeRestart("muffleWarning")
[01:29:06.431]                       }
[01:29:06.431]                       else if (inherits(cond, "condition")) {
[01:29:06.431]                         if (!is.null(pattern)) {
[01:29:06.431]                           computeRestarts <- base::computeRestarts
[01:29:06.431]                           grepl <- base::grepl
[01:29:06.431]                           restarts <- computeRestarts(cond)
[01:29:06.431]                           for (restart in restarts) {
[01:29:06.431]                             name <- restart$name
[01:29:06.431]                             if (is.null(name)) 
[01:29:06.431]                               next
[01:29:06.431]                             if (!grepl(pattern, name)) 
[01:29:06.431]                               next
[01:29:06.431]                             invokeRestart(restart)
[01:29:06.431]                             muffled <- TRUE
[01:29:06.431]                             break
[01:29:06.431]                           }
[01:29:06.431]                         }
[01:29:06.431]                       }
[01:29:06.431]                       invisible(muffled)
[01:29:06.431]                     }
[01:29:06.431]                     muffleCondition(cond, pattern = "^muffle")
[01:29:06.431]                   }
[01:29:06.431]                 }
[01:29:06.431]             }
[01:29:06.431]         }))
[01:29:06.431]     }, error = function(ex) {
[01:29:06.431]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:06.431]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:06.431]                 ...future.rng), started = ...future.startTime, 
[01:29:06.431]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:06.431]             version = "1.8"), class = "FutureResult")
[01:29:06.431]     }, finally = {
[01:29:06.431]         if (!identical(...future.workdir, getwd())) 
[01:29:06.431]             setwd(...future.workdir)
[01:29:06.431]         {
[01:29:06.431]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:06.431]                 ...future.oldOptions$nwarnings <- NULL
[01:29:06.431]             }
[01:29:06.431]             base::options(...future.oldOptions)
[01:29:06.431]             if (.Platform$OS.type == "windows") {
[01:29:06.431]                 old_names <- names(...future.oldEnvVars)
[01:29:06.431]                 envs <- base::Sys.getenv()
[01:29:06.431]                 names <- names(envs)
[01:29:06.431]                 common <- intersect(names, old_names)
[01:29:06.431]                 added <- setdiff(names, old_names)
[01:29:06.431]                 removed <- setdiff(old_names, names)
[01:29:06.431]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:06.431]                   envs[common]]
[01:29:06.431]                 NAMES <- toupper(changed)
[01:29:06.431]                 args <- list()
[01:29:06.431]                 for (kk in seq_along(NAMES)) {
[01:29:06.431]                   name <- changed[[kk]]
[01:29:06.431]                   NAME <- NAMES[[kk]]
[01:29:06.431]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:06.431]                     next
[01:29:06.431]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:06.431]                 }
[01:29:06.431]                 NAMES <- toupper(added)
[01:29:06.431]                 for (kk in seq_along(NAMES)) {
[01:29:06.431]                   name <- added[[kk]]
[01:29:06.431]                   NAME <- NAMES[[kk]]
[01:29:06.431]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:06.431]                     next
[01:29:06.431]                   args[[name]] <- ""
[01:29:06.431]                 }
[01:29:06.431]                 NAMES <- toupper(removed)
[01:29:06.431]                 for (kk in seq_along(NAMES)) {
[01:29:06.431]                   name <- removed[[kk]]
[01:29:06.431]                   NAME <- NAMES[[kk]]
[01:29:06.431]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:06.431]                     next
[01:29:06.431]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:06.431]                 }
[01:29:06.431]                 if (length(args) > 0) 
[01:29:06.431]                   base::do.call(base::Sys.setenv, args = args)
[01:29:06.431]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:06.431]             }
[01:29:06.431]             else {
[01:29:06.431]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:06.431]             }
[01:29:06.431]             {
[01:29:06.431]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:06.431]                   0L) {
[01:29:06.431]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:06.431]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:06.431]                   base::options(opts)
[01:29:06.431]                 }
[01:29:06.431]                 {
[01:29:06.431]                   {
[01:29:06.431]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:06.431]                     NULL
[01:29:06.431]                   }
[01:29:06.431]                   options(future.plan = NULL)
[01:29:06.431]                   if (is.na(NA_character_)) 
[01:29:06.431]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:06.431]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:06.431]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:06.431]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:06.431]                     envir = parent.frame()) 
[01:29:06.431]                   {
[01:29:06.431]                     if (is.function(workers)) 
[01:29:06.431]                       workers <- workers()
[01:29:06.431]                     workers <- structure(as.integer(workers), 
[01:29:06.431]                       class = class(workers))
[01:29:06.431]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:06.431]                       workers >= 1)
[01:29:06.431]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:06.431]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:06.431]                     }
[01:29:06.431]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:06.431]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:06.431]                       envir = envir)
[01:29:06.431]                     if (!future$lazy) 
[01:29:06.431]                       future <- run(future)
[01:29:06.431]                     invisible(future)
[01:29:06.431]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:06.431]                 }
[01:29:06.431]             }
[01:29:06.431]         }
[01:29:06.431]     })
[01:29:06.431]     if (TRUE) {
[01:29:06.431]         base::sink(type = "output", split = FALSE)
[01:29:06.431]         if (TRUE) {
[01:29:06.431]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:06.431]         }
[01:29:06.431]         else {
[01:29:06.431]             ...future.result["stdout"] <- base::list(NULL)
[01:29:06.431]         }
[01:29:06.431]         base::close(...future.stdout)
[01:29:06.431]         ...future.stdout <- NULL
[01:29:06.431]     }
[01:29:06.431]     ...future.result$conditions <- ...future.conditions
[01:29:06.431]     ...future.result$finished <- base::Sys.time()
[01:29:06.431]     ...future.result
[01:29:06.431] }
[01:29:06.436] Poll #1 (0): usedNodes() = 2, workers = 2
[01:29:06.462] receiveMessageFromWorker() for ClusterFuture ...
[01:29:06.463] - Validating connection of MultisessionFuture
[01:29:06.463] - received message: FutureResult
[01:29:06.463] - Received FutureResult
[01:29:06.463] - Erased future from FutureRegistry
[01:29:06.463] result() for ClusterFuture ...
[01:29:06.464] - result already collected: FutureResult
[01:29:06.464] result() for ClusterFuture ... done
[01:29:06.464] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:06.464] result() for ClusterFuture ...
[01:29:06.464] - result already collected: FutureResult
[01:29:06.465] result() for ClusterFuture ... done
[01:29:06.465] result() for ClusterFuture ...
[01:29:06.465] - result already collected: FutureResult
[01:29:06.465] result() for ClusterFuture ... done
[01:29:06.466] MultisessionFuture started
[01:29:06.467] - Launch lazy future ... done
[01:29:06.467] run() for 'MultisessionFuture' ... done
[01:29:06.467] getGlobalsAndPackages() ...
[01:29:06.467] Searching for globals...
[01:29:06.468] - globals found: [2] 'list', 'stop'
[01:29:06.468] Searching for globals ... DONE
[01:29:06.468] Resolving globals: FALSE
[01:29:06.469] 
[01:29:06.469] 
[01:29:06.469] getGlobalsAndPackages() ... DONE
- result = TRUE, recursive = -1 ... DONE
- result = TRUE, recursive = 0 ...
[01:29:06.470] getGlobalsAndPackages() ...
[01:29:06.470] Searching for globals...
[01:29:06.471] - globals found: [3] '{', 'Sys.sleep', 'list'
[01:29:06.471] Searching for globals ... DONE
[01:29:06.471] Resolving globals: FALSE
[01:29:06.472] 
[01:29:06.472] 
[01:29:06.472] getGlobalsAndPackages() ... DONE
[01:29:06.472] run() for 'Future' ...
[01:29:06.473] - state: 'created'
[01:29:06.473] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:06.487] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:06.488] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:06.488]   - Field: 'node'
[01:29:06.488]   - Field: 'label'
[01:29:06.489]   - Field: 'local'
[01:29:06.489]   - Field: 'owner'
[01:29:06.489]   - Field: 'envir'
[01:29:06.490]   - Field: 'workers'
[01:29:06.490]   - Field: 'packages'
[01:29:06.490]   - Field: 'gc'
[01:29:06.491]   - Field: 'conditions'
[01:29:06.491]   - Field: 'persistent'
[01:29:06.491]   - Field: 'expr'
[01:29:06.492]   - Field: 'uuid'
[01:29:06.492]   - Field: 'seed'
[01:29:06.492]   - Field: 'version'
[01:29:06.493]   - Field: 'result'
[01:29:06.493]   - Field: 'asynchronous'
[01:29:06.493]   - Field: 'calls'
[01:29:06.494]   - Field: 'globals'
[01:29:06.494]   - Field: 'stdout'
[01:29:06.494]   - Field: 'earlySignal'
[01:29:06.495]   - Field: 'lazy'
[01:29:06.495]   - Field: 'state'
[01:29:06.495] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:06.496] - Launch lazy future ...
[01:29:06.496] Packages needed by the future expression (n = 0): <none>
[01:29:06.497] Packages needed by future strategies (n = 0): <none>
[01:29:06.498] {
[01:29:06.498]     {
[01:29:06.498]         {
[01:29:06.498]             ...future.startTime <- base::Sys.time()
[01:29:06.498]             {
[01:29:06.498]                 {
[01:29:06.498]                   {
[01:29:06.498]                     {
[01:29:06.498]                       base::local({
[01:29:06.498]                         has_future <- base::requireNamespace("future", 
[01:29:06.498]                           quietly = TRUE)
[01:29:06.498]                         if (has_future) {
[01:29:06.498]                           ns <- base::getNamespace("future")
[01:29:06.498]                           version <- ns[[".package"]][["version"]]
[01:29:06.498]                           if (is.null(version)) 
[01:29:06.498]                             version <- utils::packageVersion("future")
[01:29:06.498]                         }
[01:29:06.498]                         else {
[01:29:06.498]                           version <- NULL
[01:29:06.498]                         }
[01:29:06.498]                         if (!has_future || version < "1.8.0") {
[01:29:06.498]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:06.498]                             "", base::R.version$version.string), 
[01:29:06.498]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:06.498]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:06.498]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:06.498]                               "release", "version")], collapse = " "), 
[01:29:06.498]                             hostname = base::Sys.info()[["nodename"]])
[01:29:06.498]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:06.498]                             info)
[01:29:06.498]                           info <- base::paste(info, collapse = "; ")
[01:29:06.498]                           if (!has_future) {
[01:29:06.498]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:06.498]                               info)
[01:29:06.498]                           }
[01:29:06.498]                           else {
[01:29:06.498]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:06.498]                               info, version)
[01:29:06.498]                           }
[01:29:06.498]                           base::stop(msg)
[01:29:06.498]                         }
[01:29:06.498]                       })
[01:29:06.498]                     }
[01:29:06.498]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:06.498]                     base::options(mc.cores = 1L)
[01:29:06.498]                   }
[01:29:06.498]                   options(future.plan = NULL)
[01:29:06.498]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:06.498]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:06.498]                 }
[01:29:06.498]                 ...future.workdir <- getwd()
[01:29:06.498]             }
[01:29:06.498]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:06.498]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:06.498]         }
[01:29:06.498]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:06.498]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:06.498]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:06.498]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:06.498]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:06.498]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:06.498]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:06.498]             base::names(...future.oldOptions))
[01:29:06.498]     }
[01:29:06.498]     if (FALSE) {
[01:29:06.498]     }
[01:29:06.498]     else {
[01:29:06.498]         if (TRUE) {
[01:29:06.498]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:06.498]                 open = "w")
[01:29:06.498]         }
[01:29:06.498]         else {
[01:29:06.498]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:06.498]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:06.498]         }
[01:29:06.498]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:06.498]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:06.498]             base::sink(type = "output", split = FALSE)
[01:29:06.498]             base::close(...future.stdout)
[01:29:06.498]         }, add = TRUE)
[01:29:06.498]     }
[01:29:06.498]     ...future.frame <- base::sys.nframe()
[01:29:06.498]     ...future.conditions <- base::list()
[01:29:06.498]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:06.498]     if (FALSE) {
[01:29:06.498]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:06.498]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:06.498]     }
[01:29:06.498]     ...future.result <- base::tryCatch({
[01:29:06.498]         base::withCallingHandlers({
[01:29:06.498]             ...future.value <- base::withVisible(base::local({
[01:29:06.498]                 ...future.makeSendCondition <- base::local({
[01:29:06.498]                   sendCondition <- NULL
[01:29:06.498]                   function(frame = 1L) {
[01:29:06.498]                     if (is.function(sendCondition)) 
[01:29:06.498]                       return(sendCondition)
[01:29:06.498]                     ns <- getNamespace("parallel")
[01:29:06.498]                     if (exists("sendData", mode = "function", 
[01:29:06.498]                       envir = ns)) {
[01:29:06.498]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:06.498]                         envir = ns)
[01:29:06.498]                       envir <- sys.frame(frame)
[01:29:06.498]                       master <- NULL
[01:29:06.498]                       while (!identical(envir, .GlobalEnv) && 
[01:29:06.498]                         !identical(envir, emptyenv())) {
[01:29:06.498]                         if (exists("master", mode = "list", envir = envir, 
[01:29:06.498]                           inherits = FALSE)) {
[01:29:06.498]                           master <- get("master", mode = "list", 
[01:29:06.498]                             envir = envir, inherits = FALSE)
[01:29:06.498]                           if (inherits(master, c("SOCKnode", 
[01:29:06.498]                             "SOCK0node"))) {
[01:29:06.498]                             sendCondition <<- function(cond) {
[01:29:06.498]                               data <- list(type = "VALUE", value = cond, 
[01:29:06.498]                                 success = TRUE)
[01:29:06.498]                               parallel_sendData(master, data)
[01:29:06.498]                             }
[01:29:06.498]                             return(sendCondition)
[01:29:06.498]                           }
[01:29:06.498]                         }
[01:29:06.498]                         frame <- frame + 1L
[01:29:06.498]                         envir <- sys.frame(frame)
[01:29:06.498]                       }
[01:29:06.498]                     }
[01:29:06.498]                     sendCondition <<- function(cond) NULL
[01:29:06.498]                   }
[01:29:06.498]                 })
[01:29:06.498]                 withCallingHandlers({
[01:29:06.498]                   {
[01:29:06.498]                     Sys.sleep(0.5)
[01:29:06.498]                     list(a = 1, b = 42L)
[01:29:06.498]                   }
[01:29:06.498]                 }, immediateCondition = function(cond) {
[01:29:06.498]                   sendCondition <- ...future.makeSendCondition()
[01:29:06.498]                   sendCondition(cond)
[01:29:06.498]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:06.498]                   {
[01:29:06.498]                     inherits <- base::inherits
[01:29:06.498]                     invokeRestart <- base::invokeRestart
[01:29:06.498]                     is.null <- base::is.null
[01:29:06.498]                     muffled <- FALSE
[01:29:06.498]                     if (inherits(cond, "message")) {
[01:29:06.498]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:06.498]                       if (muffled) 
[01:29:06.498]                         invokeRestart("muffleMessage")
[01:29:06.498]                     }
[01:29:06.498]                     else if (inherits(cond, "warning")) {
[01:29:06.498]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:06.498]                       if (muffled) 
[01:29:06.498]                         invokeRestart("muffleWarning")
[01:29:06.498]                     }
[01:29:06.498]                     else if (inherits(cond, "condition")) {
[01:29:06.498]                       if (!is.null(pattern)) {
[01:29:06.498]                         computeRestarts <- base::computeRestarts
[01:29:06.498]                         grepl <- base::grepl
[01:29:06.498]                         restarts <- computeRestarts(cond)
[01:29:06.498]                         for (restart in restarts) {
[01:29:06.498]                           name <- restart$name
[01:29:06.498]                           if (is.null(name)) 
[01:29:06.498]                             next
[01:29:06.498]                           if (!grepl(pattern, name)) 
[01:29:06.498]                             next
[01:29:06.498]                           invokeRestart(restart)
[01:29:06.498]                           muffled <- TRUE
[01:29:06.498]                           break
[01:29:06.498]                         }
[01:29:06.498]                       }
[01:29:06.498]                     }
[01:29:06.498]                     invisible(muffled)
[01:29:06.498]                   }
[01:29:06.498]                   muffleCondition(cond)
[01:29:06.498]                 })
[01:29:06.498]             }))
[01:29:06.498]             future::FutureResult(value = ...future.value$value, 
[01:29:06.498]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:06.498]                   ...future.rng), globalenv = if (FALSE) 
[01:29:06.498]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:06.498]                     ...future.globalenv.names))
[01:29:06.498]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:06.498]         }, condition = base::local({
[01:29:06.498]             c <- base::c
[01:29:06.498]             inherits <- base::inherits
[01:29:06.498]             invokeRestart <- base::invokeRestart
[01:29:06.498]             length <- base::length
[01:29:06.498]             list <- base::list
[01:29:06.498]             seq.int <- base::seq.int
[01:29:06.498]             signalCondition <- base::signalCondition
[01:29:06.498]             sys.calls <- base::sys.calls
[01:29:06.498]             `[[` <- base::`[[`
[01:29:06.498]             `+` <- base::`+`
[01:29:06.498]             `<<-` <- base::`<<-`
[01:29:06.498]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:06.498]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:06.498]                   3L)]
[01:29:06.498]             }
[01:29:06.498]             function(cond) {
[01:29:06.498]                 is_error <- inherits(cond, "error")
[01:29:06.498]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:06.498]                   NULL)
[01:29:06.498]                 if (is_error) {
[01:29:06.498]                   sessionInformation <- function() {
[01:29:06.498]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:06.498]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:06.498]                       search = base::search(), system = base::Sys.info())
[01:29:06.498]                   }
[01:29:06.498]                   ...future.conditions[[length(...future.conditions) + 
[01:29:06.498]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:06.498]                     cond$call), session = sessionInformation(), 
[01:29:06.498]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:06.498]                   signalCondition(cond)
[01:29:06.498]                 }
[01:29:06.498]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:06.498]                 "immediateCondition"))) {
[01:29:06.498]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:06.498]                   ...future.conditions[[length(...future.conditions) + 
[01:29:06.498]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:06.498]                   if (TRUE && !signal) {
[01:29:06.498]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:06.498]                     {
[01:29:06.498]                       inherits <- base::inherits
[01:29:06.498]                       invokeRestart <- base::invokeRestart
[01:29:06.498]                       is.null <- base::is.null
[01:29:06.498]                       muffled <- FALSE
[01:29:06.498]                       if (inherits(cond, "message")) {
[01:29:06.498]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:06.498]                         if (muffled) 
[01:29:06.498]                           invokeRestart("muffleMessage")
[01:29:06.498]                       }
[01:29:06.498]                       else if (inherits(cond, "warning")) {
[01:29:06.498]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:06.498]                         if (muffled) 
[01:29:06.498]                           invokeRestart("muffleWarning")
[01:29:06.498]                       }
[01:29:06.498]                       else if (inherits(cond, "condition")) {
[01:29:06.498]                         if (!is.null(pattern)) {
[01:29:06.498]                           computeRestarts <- base::computeRestarts
[01:29:06.498]                           grepl <- base::grepl
[01:29:06.498]                           restarts <- computeRestarts(cond)
[01:29:06.498]                           for (restart in restarts) {
[01:29:06.498]                             name <- restart$name
[01:29:06.498]                             if (is.null(name)) 
[01:29:06.498]                               next
[01:29:06.498]                             if (!grepl(pattern, name)) 
[01:29:06.498]                               next
[01:29:06.498]                             invokeRestart(restart)
[01:29:06.498]                             muffled <- TRUE
[01:29:06.498]                             break
[01:29:06.498]                           }
[01:29:06.498]                         }
[01:29:06.498]                       }
[01:29:06.498]                       invisible(muffled)
[01:29:06.498]                     }
[01:29:06.498]                     muffleCondition(cond, pattern = "^muffle")
[01:29:06.498]                   }
[01:29:06.498]                 }
[01:29:06.498]                 else {
[01:29:06.498]                   if (TRUE) {
[01:29:06.498]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:06.498]                     {
[01:29:06.498]                       inherits <- base::inherits
[01:29:06.498]                       invokeRestart <- base::invokeRestart
[01:29:06.498]                       is.null <- base::is.null
[01:29:06.498]                       muffled <- FALSE
[01:29:06.498]                       if (inherits(cond, "message")) {
[01:29:06.498]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:06.498]                         if (muffled) 
[01:29:06.498]                           invokeRestart("muffleMessage")
[01:29:06.498]                       }
[01:29:06.498]                       else if (inherits(cond, "warning")) {
[01:29:06.498]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:06.498]                         if (muffled) 
[01:29:06.498]                           invokeRestart("muffleWarning")
[01:29:06.498]                       }
[01:29:06.498]                       else if (inherits(cond, "condition")) {
[01:29:06.498]                         if (!is.null(pattern)) {
[01:29:06.498]                           computeRestarts <- base::computeRestarts
[01:29:06.498]                           grepl <- base::grepl
[01:29:06.498]                           restarts <- computeRestarts(cond)
[01:29:06.498]                           for (restart in restarts) {
[01:29:06.498]                             name <- restart$name
[01:29:06.498]                             if (is.null(name)) 
[01:29:06.498]                               next
[01:29:06.498]                             if (!grepl(pattern, name)) 
[01:29:06.498]                               next
[01:29:06.498]                             invokeRestart(restart)
[01:29:06.498]                             muffled <- TRUE
[01:29:06.498]                             break
[01:29:06.498]                           }
[01:29:06.498]                         }
[01:29:06.498]                       }
[01:29:06.498]                       invisible(muffled)
[01:29:06.498]                     }
[01:29:06.498]                     muffleCondition(cond, pattern = "^muffle")
[01:29:06.498]                   }
[01:29:06.498]                 }
[01:29:06.498]             }
[01:29:06.498]         }))
[01:29:06.498]     }, error = function(ex) {
[01:29:06.498]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:06.498]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:06.498]                 ...future.rng), started = ...future.startTime, 
[01:29:06.498]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:06.498]             version = "1.8"), class = "FutureResult")
[01:29:06.498]     }, finally = {
[01:29:06.498]         if (!identical(...future.workdir, getwd())) 
[01:29:06.498]             setwd(...future.workdir)
[01:29:06.498]         {
[01:29:06.498]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:06.498]                 ...future.oldOptions$nwarnings <- NULL
[01:29:06.498]             }
[01:29:06.498]             base::options(...future.oldOptions)
[01:29:06.498]             if (.Platform$OS.type == "windows") {
[01:29:06.498]                 old_names <- names(...future.oldEnvVars)
[01:29:06.498]                 envs <- base::Sys.getenv()
[01:29:06.498]                 names <- names(envs)
[01:29:06.498]                 common <- intersect(names, old_names)
[01:29:06.498]                 added <- setdiff(names, old_names)
[01:29:06.498]                 removed <- setdiff(old_names, names)
[01:29:06.498]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:06.498]                   envs[common]]
[01:29:06.498]                 NAMES <- toupper(changed)
[01:29:06.498]                 args <- list()
[01:29:06.498]                 for (kk in seq_along(NAMES)) {
[01:29:06.498]                   name <- changed[[kk]]
[01:29:06.498]                   NAME <- NAMES[[kk]]
[01:29:06.498]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:06.498]                     next
[01:29:06.498]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:06.498]                 }
[01:29:06.498]                 NAMES <- toupper(added)
[01:29:06.498]                 for (kk in seq_along(NAMES)) {
[01:29:06.498]                   name <- added[[kk]]
[01:29:06.498]                   NAME <- NAMES[[kk]]
[01:29:06.498]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:06.498]                     next
[01:29:06.498]                   args[[name]] <- ""
[01:29:06.498]                 }
[01:29:06.498]                 NAMES <- toupper(removed)
[01:29:06.498]                 for (kk in seq_along(NAMES)) {
[01:29:06.498]                   name <- removed[[kk]]
[01:29:06.498]                   NAME <- NAMES[[kk]]
[01:29:06.498]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:06.498]                     next
[01:29:06.498]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:06.498]                 }
[01:29:06.498]                 if (length(args) > 0) 
[01:29:06.498]                   base::do.call(base::Sys.setenv, args = args)
[01:29:06.498]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:06.498]             }
[01:29:06.498]             else {
[01:29:06.498]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:06.498]             }
[01:29:06.498]             {
[01:29:06.498]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:06.498]                   0L) {
[01:29:06.498]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:06.498]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:06.498]                   base::options(opts)
[01:29:06.498]                 }
[01:29:06.498]                 {
[01:29:06.498]                   {
[01:29:06.498]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:06.498]                     NULL
[01:29:06.498]                   }
[01:29:06.498]                   options(future.plan = NULL)
[01:29:06.498]                   if (is.na(NA_character_)) 
[01:29:06.498]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:06.498]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:06.498]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:06.498]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:06.498]                     envir = parent.frame()) 
[01:29:06.498]                   {
[01:29:06.498]                     if (is.function(workers)) 
[01:29:06.498]                       workers <- workers()
[01:29:06.498]                     workers <- structure(as.integer(workers), 
[01:29:06.498]                       class = class(workers))
[01:29:06.498]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:06.498]                       workers >= 1)
[01:29:06.498]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:06.498]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:06.498]                     }
[01:29:06.498]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:06.498]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:06.498]                       envir = envir)
[01:29:06.498]                     if (!future$lazy) 
[01:29:06.498]                       future <- run(future)
[01:29:06.498]                     invisible(future)
[01:29:06.498]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:06.498]                 }
[01:29:06.498]             }
[01:29:06.498]         }
[01:29:06.498]     })
[01:29:06.498]     if (TRUE) {
[01:29:06.498]         base::sink(type = "output", split = FALSE)
[01:29:06.498]         if (TRUE) {
[01:29:06.498]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:06.498]         }
[01:29:06.498]         else {
[01:29:06.498]             ...future.result["stdout"] <- base::list(NULL)
[01:29:06.498]         }
[01:29:06.498]         base::close(...future.stdout)
[01:29:06.498]         ...future.stdout <- NULL
[01:29:06.498]     }
[01:29:06.498]     ...future.result$conditions <- ...future.conditions
[01:29:06.498]     ...future.result$finished <- base::Sys.time()
[01:29:06.498]     ...future.result
[01:29:06.498] }
[01:29:06.504] Poll #1 (0): usedNodes() = 2, workers = 2
[01:29:06.719] receiveMessageFromWorker() for ClusterFuture ...
[01:29:06.720] - Validating connection of MultisessionFuture
[01:29:06.720] - received message: FutureResult
[01:29:06.721] - Received FutureResult
[01:29:06.721] - Erased future from FutureRegistry
[01:29:06.721] result() for ClusterFuture ...
[01:29:06.721] - result already collected: FutureResult
[01:29:06.721] result() for ClusterFuture ... done
[01:29:06.721] signalConditions() ...
[01:29:06.722]  - include = 'immediateCondition'
[01:29:06.722]  - exclude = 
[01:29:06.722]  - resignal = FALSE
[01:29:06.722]  - Number of conditions: 1
[01:29:06.722] signalConditions() ... done
[01:29:06.722] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:06.723] result() for ClusterFuture ...
[01:29:06.723] - result already collected: FutureResult
[01:29:06.723] result() for ClusterFuture ... done
[01:29:06.723] result() for ClusterFuture ...
[01:29:06.723] - result already collected: FutureResult
[01:29:06.723] result() for ClusterFuture ... done
[01:29:06.724] signalConditions() ...
[01:29:06.724]  - include = 'immediateCondition'
[01:29:06.724]  - exclude = 
[01:29:06.724]  - resignal = FALSE
[01:29:06.724]  - Number of conditions: 1
[01:29:06.724] signalConditions() ... done
[01:29:06.726] MultisessionFuture started
[01:29:06.726] - Launch lazy future ... done
[01:29:06.726] run() for 'MultisessionFuture' ... done
[01:29:07.256] receiveMessageFromWorker() for ClusterFuture ...
[01:29:07.257] - Validating connection of MultisessionFuture
[01:29:07.257] - received message: FutureResult
[01:29:07.258] - Received FutureResult
[01:29:07.258] - Erased future from FutureRegistry
[01:29:07.258] result() for ClusterFuture ...
[01:29:07.258] - result already collected: FutureResult
[01:29:07.258] result() for ClusterFuture ... done
[01:29:07.258] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:07.259] A MultisessionFuture was resolved
[01:29:07.259] getGlobalsAndPackages() ...
[01:29:07.259] Searching for globals...
[01:29:07.261] - globals found: [3] '{', 'Sys.sleep', 'list'
[01:29:07.261] Searching for globals ... DONE
[01:29:07.261] Resolving globals: FALSE
[01:29:07.261] 
[01:29:07.262] 
[01:29:07.262] getGlobalsAndPackages() ... DONE
[01:29:07.262] run() for 'Future' ...
[01:29:07.262] - state: 'created'
[01:29:07.263] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:07.277] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:07.277] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:07.278]   - Field: 'node'
[01:29:07.278]   - Field: 'label'
[01:29:07.278]   - Field: 'local'
[01:29:07.278]   - Field: 'owner'
[01:29:07.278]   - Field: 'envir'
[01:29:07.279]   - Field: 'workers'
[01:29:07.279]   - Field: 'packages'
[01:29:07.279]   - Field: 'gc'
[01:29:07.279]   - Field: 'conditions'
[01:29:07.279]   - Field: 'persistent'
[01:29:07.280]   - Field: 'expr'
[01:29:07.280]   - Field: 'uuid'
[01:29:07.280]   - Field: 'seed'
[01:29:07.280]   - Field: 'version'
[01:29:07.280]   - Field: 'result'
[01:29:07.280]   - Field: 'asynchronous'
[01:29:07.281]   - Field: 'calls'
[01:29:07.281]   - Field: 'globals'
[01:29:07.281]   - Field: 'stdout'
[01:29:07.281]   - Field: 'earlySignal'
[01:29:07.281]   - Field: 'lazy'
[01:29:07.282]   - Field: 'state'
[01:29:07.282] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:07.282] - Launch lazy future ...
[01:29:07.282] Packages needed by the future expression (n = 0): <none>
[01:29:07.283] Packages needed by future strategies (n = 0): <none>
[01:29:07.283] {
[01:29:07.283]     {
[01:29:07.283]         {
[01:29:07.283]             ...future.startTime <- base::Sys.time()
[01:29:07.283]             {
[01:29:07.283]                 {
[01:29:07.283]                   {
[01:29:07.283]                     {
[01:29:07.283]                       base::local({
[01:29:07.283]                         has_future <- base::requireNamespace("future", 
[01:29:07.283]                           quietly = TRUE)
[01:29:07.283]                         if (has_future) {
[01:29:07.283]                           ns <- base::getNamespace("future")
[01:29:07.283]                           version <- ns[[".package"]][["version"]]
[01:29:07.283]                           if (is.null(version)) 
[01:29:07.283]                             version <- utils::packageVersion("future")
[01:29:07.283]                         }
[01:29:07.283]                         else {
[01:29:07.283]                           version <- NULL
[01:29:07.283]                         }
[01:29:07.283]                         if (!has_future || version < "1.8.0") {
[01:29:07.283]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:07.283]                             "", base::R.version$version.string), 
[01:29:07.283]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:07.283]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:07.283]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:07.283]                               "release", "version")], collapse = " "), 
[01:29:07.283]                             hostname = base::Sys.info()[["nodename"]])
[01:29:07.283]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:07.283]                             info)
[01:29:07.283]                           info <- base::paste(info, collapse = "; ")
[01:29:07.283]                           if (!has_future) {
[01:29:07.283]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:07.283]                               info)
[01:29:07.283]                           }
[01:29:07.283]                           else {
[01:29:07.283]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:07.283]                               info, version)
[01:29:07.283]                           }
[01:29:07.283]                           base::stop(msg)
[01:29:07.283]                         }
[01:29:07.283]                       })
[01:29:07.283]                     }
[01:29:07.283]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:07.283]                     base::options(mc.cores = 1L)
[01:29:07.283]                   }
[01:29:07.283]                   options(future.plan = NULL)
[01:29:07.283]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:07.283]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:07.283]                 }
[01:29:07.283]                 ...future.workdir <- getwd()
[01:29:07.283]             }
[01:29:07.283]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:07.283]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:07.283]         }
[01:29:07.283]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:07.283]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:07.283]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:07.283]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:07.283]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:07.283]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:07.283]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:07.283]             base::names(...future.oldOptions))
[01:29:07.283]     }
[01:29:07.283]     if (FALSE) {
[01:29:07.283]     }
[01:29:07.283]     else {
[01:29:07.283]         if (TRUE) {
[01:29:07.283]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:07.283]                 open = "w")
[01:29:07.283]         }
[01:29:07.283]         else {
[01:29:07.283]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:07.283]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:07.283]         }
[01:29:07.283]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:07.283]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:07.283]             base::sink(type = "output", split = FALSE)
[01:29:07.283]             base::close(...future.stdout)
[01:29:07.283]         }, add = TRUE)
[01:29:07.283]     }
[01:29:07.283]     ...future.frame <- base::sys.nframe()
[01:29:07.283]     ...future.conditions <- base::list()
[01:29:07.283]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:07.283]     if (FALSE) {
[01:29:07.283]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:07.283]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:07.283]     }
[01:29:07.283]     ...future.result <- base::tryCatch({
[01:29:07.283]         base::withCallingHandlers({
[01:29:07.283]             ...future.value <- base::withVisible(base::local({
[01:29:07.283]                 ...future.makeSendCondition <- base::local({
[01:29:07.283]                   sendCondition <- NULL
[01:29:07.283]                   function(frame = 1L) {
[01:29:07.283]                     if (is.function(sendCondition)) 
[01:29:07.283]                       return(sendCondition)
[01:29:07.283]                     ns <- getNamespace("parallel")
[01:29:07.283]                     if (exists("sendData", mode = "function", 
[01:29:07.283]                       envir = ns)) {
[01:29:07.283]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:07.283]                         envir = ns)
[01:29:07.283]                       envir <- sys.frame(frame)
[01:29:07.283]                       master <- NULL
[01:29:07.283]                       while (!identical(envir, .GlobalEnv) && 
[01:29:07.283]                         !identical(envir, emptyenv())) {
[01:29:07.283]                         if (exists("master", mode = "list", envir = envir, 
[01:29:07.283]                           inherits = FALSE)) {
[01:29:07.283]                           master <- get("master", mode = "list", 
[01:29:07.283]                             envir = envir, inherits = FALSE)
[01:29:07.283]                           if (inherits(master, c("SOCKnode", 
[01:29:07.283]                             "SOCK0node"))) {
[01:29:07.283]                             sendCondition <<- function(cond) {
[01:29:07.283]                               data <- list(type = "VALUE", value = cond, 
[01:29:07.283]                                 success = TRUE)
[01:29:07.283]                               parallel_sendData(master, data)
[01:29:07.283]                             }
[01:29:07.283]                             return(sendCondition)
[01:29:07.283]                           }
[01:29:07.283]                         }
[01:29:07.283]                         frame <- frame + 1L
[01:29:07.283]                         envir <- sys.frame(frame)
[01:29:07.283]                       }
[01:29:07.283]                     }
[01:29:07.283]                     sendCondition <<- function(cond) NULL
[01:29:07.283]                   }
[01:29:07.283]                 })
[01:29:07.283]                 withCallingHandlers({
[01:29:07.283]                   {
[01:29:07.283]                     Sys.sleep(0.5)
[01:29:07.283]                     list(a = 1, b = 42L)
[01:29:07.283]                   }
[01:29:07.283]                 }, immediateCondition = function(cond) {
[01:29:07.283]                   sendCondition <- ...future.makeSendCondition()
[01:29:07.283]                   sendCondition(cond)
[01:29:07.283]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:07.283]                   {
[01:29:07.283]                     inherits <- base::inherits
[01:29:07.283]                     invokeRestart <- base::invokeRestart
[01:29:07.283]                     is.null <- base::is.null
[01:29:07.283]                     muffled <- FALSE
[01:29:07.283]                     if (inherits(cond, "message")) {
[01:29:07.283]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:07.283]                       if (muffled) 
[01:29:07.283]                         invokeRestart("muffleMessage")
[01:29:07.283]                     }
[01:29:07.283]                     else if (inherits(cond, "warning")) {
[01:29:07.283]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:07.283]                       if (muffled) 
[01:29:07.283]                         invokeRestart("muffleWarning")
[01:29:07.283]                     }
[01:29:07.283]                     else if (inherits(cond, "condition")) {
[01:29:07.283]                       if (!is.null(pattern)) {
[01:29:07.283]                         computeRestarts <- base::computeRestarts
[01:29:07.283]                         grepl <- base::grepl
[01:29:07.283]                         restarts <- computeRestarts(cond)
[01:29:07.283]                         for (restart in restarts) {
[01:29:07.283]                           name <- restart$name
[01:29:07.283]                           if (is.null(name)) 
[01:29:07.283]                             next
[01:29:07.283]                           if (!grepl(pattern, name)) 
[01:29:07.283]                             next
[01:29:07.283]                           invokeRestart(restart)
[01:29:07.283]                           muffled <- TRUE
[01:29:07.283]                           break
[01:29:07.283]                         }
[01:29:07.283]                       }
[01:29:07.283]                     }
[01:29:07.283]                     invisible(muffled)
[01:29:07.283]                   }
[01:29:07.283]                   muffleCondition(cond)
[01:29:07.283]                 })
[01:29:07.283]             }))
[01:29:07.283]             future::FutureResult(value = ...future.value$value, 
[01:29:07.283]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:07.283]                   ...future.rng), globalenv = if (FALSE) 
[01:29:07.283]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:07.283]                     ...future.globalenv.names))
[01:29:07.283]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:07.283]         }, condition = base::local({
[01:29:07.283]             c <- base::c
[01:29:07.283]             inherits <- base::inherits
[01:29:07.283]             invokeRestart <- base::invokeRestart
[01:29:07.283]             length <- base::length
[01:29:07.283]             list <- base::list
[01:29:07.283]             seq.int <- base::seq.int
[01:29:07.283]             signalCondition <- base::signalCondition
[01:29:07.283]             sys.calls <- base::sys.calls
[01:29:07.283]             `[[` <- base::`[[`
[01:29:07.283]             `+` <- base::`+`
[01:29:07.283]             `<<-` <- base::`<<-`
[01:29:07.283]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:07.283]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:07.283]                   3L)]
[01:29:07.283]             }
[01:29:07.283]             function(cond) {
[01:29:07.283]                 is_error <- inherits(cond, "error")
[01:29:07.283]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:07.283]                   NULL)
[01:29:07.283]                 if (is_error) {
[01:29:07.283]                   sessionInformation <- function() {
[01:29:07.283]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:07.283]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:07.283]                       search = base::search(), system = base::Sys.info())
[01:29:07.283]                   }
[01:29:07.283]                   ...future.conditions[[length(...future.conditions) + 
[01:29:07.283]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:07.283]                     cond$call), session = sessionInformation(), 
[01:29:07.283]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:07.283]                   signalCondition(cond)
[01:29:07.283]                 }
[01:29:07.283]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:07.283]                 "immediateCondition"))) {
[01:29:07.283]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:07.283]                   ...future.conditions[[length(...future.conditions) + 
[01:29:07.283]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:07.283]                   if (TRUE && !signal) {
[01:29:07.283]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:07.283]                     {
[01:29:07.283]                       inherits <- base::inherits
[01:29:07.283]                       invokeRestart <- base::invokeRestart
[01:29:07.283]                       is.null <- base::is.null
[01:29:07.283]                       muffled <- FALSE
[01:29:07.283]                       if (inherits(cond, "message")) {
[01:29:07.283]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:07.283]                         if (muffled) 
[01:29:07.283]                           invokeRestart("muffleMessage")
[01:29:07.283]                       }
[01:29:07.283]                       else if (inherits(cond, "warning")) {
[01:29:07.283]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:07.283]                         if (muffled) 
[01:29:07.283]                           invokeRestart("muffleWarning")
[01:29:07.283]                       }
[01:29:07.283]                       else if (inherits(cond, "condition")) {
[01:29:07.283]                         if (!is.null(pattern)) {
[01:29:07.283]                           computeRestarts <- base::computeRestarts
[01:29:07.283]                           grepl <- base::grepl
[01:29:07.283]                           restarts <- computeRestarts(cond)
[01:29:07.283]                           for (restart in restarts) {
[01:29:07.283]                             name <- restart$name
[01:29:07.283]                             if (is.null(name)) 
[01:29:07.283]                               next
[01:29:07.283]                             if (!grepl(pattern, name)) 
[01:29:07.283]                               next
[01:29:07.283]                             invokeRestart(restart)
[01:29:07.283]                             muffled <- TRUE
[01:29:07.283]                             break
[01:29:07.283]                           }
[01:29:07.283]                         }
[01:29:07.283]                       }
[01:29:07.283]                       invisible(muffled)
[01:29:07.283]                     }
[01:29:07.283]                     muffleCondition(cond, pattern = "^muffle")
[01:29:07.283]                   }
[01:29:07.283]                 }
[01:29:07.283]                 else {
[01:29:07.283]                   if (TRUE) {
[01:29:07.283]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:07.283]                     {
[01:29:07.283]                       inherits <- base::inherits
[01:29:07.283]                       invokeRestart <- base::invokeRestart
[01:29:07.283]                       is.null <- base::is.null
[01:29:07.283]                       muffled <- FALSE
[01:29:07.283]                       if (inherits(cond, "message")) {
[01:29:07.283]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:07.283]                         if (muffled) 
[01:29:07.283]                           invokeRestart("muffleMessage")
[01:29:07.283]                       }
[01:29:07.283]                       else if (inherits(cond, "warning")) {
[01:29:07.283]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:07.283]                         if (muffled) 
[01:29:07.283]                           invokeRestart("muffleWarning")
[01:29:07.283]                       }
[01:29:07.283]                       else if (inherits(cond, "condition")) {
[01:29:07.283]                         if (!is.null(pattern)) {
[01:29:07.283]                           computeRestarts <- base::computeRestarts
[01:29:07.283]                           grepl <- base::grepl
[01:29:07.283]                           restarts <- computeRestarts(cond)
[01:29:07.283]                           for (restart in restarts) {
[01:29:07.283]                             name <- restart$name
[01:29:07.283]                             if (is.null(name)) 
[01:29:07.283]                               next
[01:29:07.283]                             if (!grepl(pattern, name)) 
[01:29:07.283]                               next
[01:29:07.283]                             invokeRestart(restart)
[01:29:07.283]                             muffled <- TRUE
[01:29:07.283]                             break
[01:29:07.283]                           }
[01:29:07.283]                         }
[01:29:07.283]                       }
[01:29:07.283]                       invisible(muffled)
[01:29:07.283]                     }
[01:29:07.283]                     muffleCondition(cond, pattern = "^muffle")
[01:29:07.283]                   }
[01:29:07.283]                 }
[01:29:07.283]             }
[01:29:07.283]         }))
[01:29:07.283]     }, error = function(ex) {
[01:29:07.283]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:07.283]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:07.283]                 ...future.rng), started = ...future.startTime, 
[01:29:07.283]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:07.283]             version = "1.8"), class = "FutureResult")
[01:29:07.283]     }, finally = {
[01:29:07.283]         if (!identical(...future.workdir, getwd())) 
[01:29:07.283]             setwd(...future.workdir)
[01:29:07.283]         {
[01:29:07.283]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:07.283]                 ...future.oldOptions$nwarnings <- NULL
[01:29:07.283]             }
[01:29:07.283]             base::options(...future.oldOptions)
[01:29:07.283]             if (.Platform$OS.type == "windows") {
[01:29:07.283]                 old_names <- names(...future.oldEnvVars)
[01:29:07.283]                 envs <- base::Sys.getenv()
[01:29:07.283]                 names <- names(envs)
[01:29:07.283]                 common <- intersect(names, old_names)
[01:29:07.283]                 added <- setdiff(names, old_names)
[01:29:07.283]                 removed <- setdiff(old_names, names)
[01:29:07.283]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:07.283]                   envs[common]]
[01:29:07.283]                 NAMES <- toupper(changed)
[01:29:07.283]                 args <- list()
[01:29:07.283]                 for (kk in seq_along(NAMES)) {
[01:29:07.283]                   name <- changed[[kk]]
[01:29:07.283]                   NAME <- NAMES[[kk]]
[01:29:07.283]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:07.283]                     next
[01:29:07.283]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:07.283]                 }
[01:29:07.283]                 NAMES <- toupper(added)
[01:29:07.283]                 for (kk in seq_along(NAMES)) {
[01:29:07.283]                   name <- added[[kk]]
[01:29:07.283]                   NAME <- NAMES[[kk]]
[01:29:07.283]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:07.283]                     next
[01:29:07.283]                   args[[name]] <- ""
[01:29:07.283]                 }
[01:29:07.283]                 NAMES <- toupper(removed)
[01:29:07.283]                 for (kk in seq_along(NAMES)) {
[01:29:07.283]                   name <- removed[[kk]]
[01:29:07.283]                   NAME <- NAMES[[kk]]
[01:29:07.283]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:07.283]                     next
[01:29:07.283]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:07.283]                 }
[01:29:07.283]                 if (length(args) > 0) 
[01:29:07.283]                   base::do.call(base::Sys.setenv, args = args)
[01:29:07.283]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:07.283]             }
[01:29:07.283]             else {
[01:29:07.283]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:07.283]             }
[01:29:07.283]             {
[01:29:07.283]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:07.283]                   0L) {
[01:29:07.283]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:07.283]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:07.283]                   base::options(opts)
[01:29:07.283]                 }
[01:29:07.283]                 {
[01:29:07.283]                   {
[01:29:07.283]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:07.283]                     NULL
[01:29:07.283]                   }
[01:29:07.283]                   options(future.plan = NULL)
[01:29:07.283]                   if (is.na(NA_character_)) 
[01:29:07.283]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:07.283]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:07.283]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:07.283]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:07.283]                     envir = parent.frame()) 
[01:29:07.283]                   {
[01:29:07.283]                     if (is.function(workers)) 
[01:29:07.283]                       workers <- workers()
[01:29:07.283]                     workers <- structure(as.integer(workers), 
[01:29:07.283]                       class = class(workers))
[01:29:07.283]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:07.283]                       workers >= 1)
[01:29:07.283]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:07.283]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:07.283]                     }
[01:29:07.283]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:07.283]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:07.283]                       envir = envir)
[01:29:07.283]                     if (!future$lazy) 
[01:29:07.283]                       future <- run(future)
[01:29:07.283]                     invisible(future)
[01:29:07.283]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:07.283]                 }
[01:29:07.283]             }
[01:29:07.283]         }
[01:29:07.283]     })
[01:29:07.283]     if (TRUE) {
[01:29:07.283]         base::sink(type = "output", split = FALSE)
[01:29:07.283]         if (TRUE) {
[01:29:07.283]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:07.283]         }
[01:29:07.283]         else {
[01:29:07.283]             ...future.result["stdout"] <- base::list(NULL)
[01:29:07.283]         }
[01:29:07.283]         base::close(...future.stdout)
[01:29:07.283]         ...future.stdout <- NULL
[01:29:07.283]     }
[01:29:07.283]     ...future.result$conditions <- ...future.conditions
[01:29:07.283]     ...future.result$finished <- base::Sys.time()
[01:29:07.283]     ...future.result
[01:29:07.283] }
[01:29:07.290] MultisessionFuture started
[01:29:07.290] - Launch lazy future ... done
[01:29:07.290] run() for 'MultisessionFuture' ... done
[01:29:07.825] receiveMessageFromWorker() for ClusterFuture ...
[01:29:07.825] - Validating connection of MultisessionFuture
[01:29:07.825] - received message: FutureResult
[01:29:07.826] - Received FutureResult
[01:29:07.826] - Erased future from FutureRegistry
[01:29:07.826] result() for ClusterFuture ...
[01:29:07.826] - result already collected: FutureResult
[01:29:07.826] result() for ClusterFuture ... done
[01:29:07.827] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:07.827] A MultisessionFuture was resolved
- w/ exception ...
[01:29:07.827] getGlobalsAndPackages() ...
[01:29:07.827] Searching for globals...
[01:29:07.828] - globals found: [2] 'list', 'stop'
[01:29:07.828] Searching for globals ... DONE
[01:29:07.829] Resolving globals: FALSE
[01:29:07.829] 
[01:29:07.829] 
[01:29:07.829] getGlobalsAndPackages() ... DONE
[01:29:07.830] run() for 'Future' ...
[01:29:07.830] - state: 'created'
[01:29:07.830] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:07.845] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:07.846] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:07.846]   - Field: 'node'
[01:29:07.846]   - Field: 'label'
[01:29:07.846]   - Field: 'local'
[01:29:07.846]   - Field: 'owner'
[01:29:07.846]   - Field: 'envir'
[01:29:07.847]   - Field: 'workers'
[01:29:07.847]   - Field: 'packages'
[01:29:07.847]   - Field: 'gc'
[01:29:07.847]   - Field: 'conditions'
[01:29:07.847]   - Field: 'persistent'
[01:29:07.848]   - Field: 'expr'
[01:29:07.848]   - Field: 'uuid'
[01:29:07.848]   - Field: 'seed'
[01:29:07.848]   - Field: 'version'
[01:29:07.848]   - Field: 'result'
[01:29:07.848]   - Field: 'asynchronous'
[01:29:07.849]   - Field: 'calls'
[01:29:07.849]   - Field: 'globals'
[01:29:07.849]   - Field: 'stdout'
[01:29:07.849]   - Field: 'earlySignal'
[01:29:07.849]   - Field: 'lazy'
[01:29:07.849]   - Field: 'state'
[01:29:07.850] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:07.850] - Launch lazy future ...
[01:29:07.850] Packages needed by the future expression (n = 0): <none>
[01:29:07.850] Packages needed by future strategies (n = 0): <none>
[01:29:07.851] {
[01:29:07.851]     {
[01:29:07.851]         {
[01:29:07.851]             ...future.startTime <- base::Sys.time()
[01:29:07.851]             {
[01:29:07.851]                 {
[01:29:07.851]                   {
[01:29:07.851]                     {
[01:29:07.851]                       base::local({
[01:29:07.851]                         has_future <- base::requireNamespace("future", 
[01:29:07.851]                           quietly = TRUE)
[01:29:07.851]                         if (has_future) {
[01:29:07.851]                           ns <- base::getNamespace("future")
[01:29:07.851]                           version <- ns[[".package"]][["version"]]
[01:29:07.851]                           if (is.null(version)) 
[01:29:07.851]                             version <- utils::packageVersion("future")
[01:29:07.851]                         }
[01:29:07.851]                         else {
[01:29:07.851]                           version <- NULL
[01:29:07.851]                         }
[01:29:07.851]                         if (!has_future || version < "1.8.0") {
[01:29:07.851]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:07.851]                             "", base::R.version$version.string), 
[01:29:07.851]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:07.851]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:07.851]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:07.851]                               "release", "version")], collapse = " "), 
[01:29:07.851]                             hostname = base::Sys.info()[["nodename"]])
[01:29:07.851]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:07.851]                             info)
[01:29:07.851]                           info <- base::paste(info, collapse = "; ")
[01:29:07.851]                           if (!has_future) {
[01:29:07.851]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:07.851]                               info)
[01:29:07.851]                           }
[01:29:07.851]                           else {
[01:29:07.851]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:07.851]                               info, version)
[01:29:07.851]                           }
[01:29:07.851]                           base::stop(msg)
[01:29:07.851]                         }
[01:29:07.851]                       })
[01:29:07.851]                     }
[01:29:07.851]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:07.851]                     base::options(mc.cores = 1L)
[01:29:07.851]                   }
[01:29:07.851]                   options(future.plan = NULL)
[01:29:07.851]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:07.851]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:07.851]                 }
[01:29:07.851]                 ...future.workdir <- getwd()
[01:29:07.851]             }
[01:29:07.851]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:07.851]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:07.851]         }
[01:29:07.851]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:07.851]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:07.851]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:07.851]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:07.851]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:07.851]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:07.851]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:07.851]             base::names(...future.oldOptions))
[01:29:07.851]     }
[01:29:07.851]     if (FALSE) {
[01:29:07.851]     }
[01:29:07.851]     else {
[01:29:07.851]         if (TRUE) {
[01:29:07.851]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:07.851]                 open = "w")
[01:29:07.851]         }
[01:29:07.851]         else {
[01:29:07.851]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:07.851]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:07.851]         }
[01:29:07.851]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:07.851]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:07.851]             base::sink(type = "output", split = FALSE)
[01:29:07.851]             base::close(...future.stdout)
[01:29:07.851]         }, add = TRUE)
[01:29:07.851]     }
[01:29:07.851]     ...future.frame <- base::sys.nframe()
[01:29:07.851]     ...future.conditions <- base::list()
[01:29:07.851]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:07.851]     if (FALSE) {
[01:29:07.851]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:07.851]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:07.851]     }
[01:29:07.851]     ...future.result <- base::tryCatch({
[01:29:07.851]         base::withCallingHandlers({
[01:29:07.851]             ...future.value <- base::withVisible(base::local({
[01:29:07.851]                 ...future.makeSendCondition <- base::local({
[01:29:07.851]                   sendCondition <- NULL
[01:29:07.851]                   function(frame = 1L) {
[01:29:07.851]                     if (is.function(sendCondition)) 
[01:29:07.851]                       return(sendCondition)
[01:29:07.851]                     ns <- getNamespace("parallel")
[01:29:07.851]                     if (exists("sendData", mode = "function", 
[01:29:07.851]                       envir = ns)) {
[01:29:07.851]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:07.851]                         envir = ns)
[01:29:07.851]                       envir <- sys.frame(frame)
[01:29:07.851]                       master <- NULL
[01:29:07.851]                       while (!identical(envir, .GlobalEnv) && 
[01:29:07.851]                         !identical(envir, emptyenv())) {
[01:29:07.851]                         if (exists("master", mode = "list", envir = envir, 
[01:29:07.851]                           inherits = FALSE)) {
[01:29:07.851]                           master <- get("master", mode = "list", 
[01:29:07.851]                             envir = envir, inherits = FALSE)
[01:29:07.851]                           if (inherits(master, c("SOCKnode", 
[01:29:07.851]                             "SOCK0node"))) {
[01:29:07.851]                             sendCondition <<- function(cond) {
[01:29:07.851]                               data <- list(type = "VALUE", value = cond, 
[01:29:07.851]                                 success = TRUE)
[01:29:07.851]                               parallel_sendData(master, data)
[01:29:07.851]                             }
[01:29:07.851]                             return(sendCondition)
[01:29:07.851]                           }
[01:29:07.851]                         }
[01:29:07.851]                         frame <- frame + 1L
[01:29:07.851]                         envir <- sys.frame(frame)
[01:29:07.851]                       }
[01:29:07.851]                     }
[01:29:07.851]                     sendCondition <<- function(cond) NULL
[01:29:07.851]                   }
[01:29:07.851]                 })
[01:29:07.851]                 withCallingHandlers({
[01:29:07.851]                   list(a = 1, b = 42L, c = stop("Nah!"))
[01:29:07.851]                 }, immediateCondition = function(cond) {
[01:29:07.851]                   sendCondition <- ...future.makeSendCondition()
[01:29:07.851]                   sendCondition(cond)
[01:29:07.851]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:07.851]                   {
[01:29:07.851]                     inherits <- base::inherits
[01:29:07.851]                     invokeRestart <- base::invokeRestart
[01:29:07.851]                     is.null <- base::is.null
[01:29:07.851]                     muffled <- FALSE
[01:29:07.851]                     if (inherits(cond, "message")) {
[01:29:07.851]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:07.851]                       if (muffled) 
[01:29:07.851]                         invokeRestart("muffleMessage")
[01:29:07.851]                     }
[01:29:07.851]                     else if (inherits(cond, "warning")) {
[01:29:07.851]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:07.851]                       if (muffled) 
[01:29:07.851]                         invokeRestart("muffleWarning")
[01:29:07.851]                     }
[01:29:07.851]                     else if (inherits(cond, "condition")) {
[01:29:07.851]                       if (!is.null(pattern)) {
[01:29:07.851]                         computeRestarts <- base::computeRestarts
[01:29:07.851]                         grepl <- base::grepl
[01:29:07.851]                         restarts <- computeRestarts(cond)
[01:29:07.851]                         for (restart in restarts) {
[01:29:07.851]                           name <- restart$name
[01:29:07.851]                           if (is.null(name)) 
[01:29:07.851]                             next
[01:29:07.851]                           if (!grepl(pattern, name)) 
[01:29:07.851]                             next
[01:29:07.851]                           invokeRestart(restart)
[01:29:07.851]                           muffled <- TRUE
[01:29:07.851]                           break
[01:29:07.851]                         }
[01:29:07.851]                       }
[01:29:07.851]                     }
[01:29:07.851]                     invisible(muffled)
[01:29:07.851]                   }
[01:29:07.851]                   muffleCondition(cond)
[01:29:07.851]                 })
[01:29:07.851]             }))
[01:29:07.851]             future::FutureResult(value = ...future.value$value, 
[01:29:07.851]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:07.851]                   ...future.rng), globalenv = if (FALSE) 
[01:29:07.851]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:07.851]                     ...future.globalenv.names))
[01:29:07.851]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:07.851]         }, condition = base::local({
[01:29:07.851]             c <- base::c
[01:29:07.851]             inherits <- base::inherits
[01:29:07.851]             invokeRestart <- base::invokeRestart
[01:29:07.851]             length <- base::length
[01:29:07.851]             list <- base::list
[01:29:07.851]             seq.int <- base::seq.int
[01:29:07.851]             signalCondition <- base::signalCondition
[01:29:07.851]             sys.calls <- base::sys.calls
[01:29:07.851]             `[[` <- base::`[[`
[01:29:07.851]             `+` <- base::`+`
[01:29:07.851]             `<<-` <- base::`<<-`
[01:29:07.851]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:07.851]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:07.851]                   3L)]
[01:29:07.851]             }
[01:29:07.851]             function(cond) {
[01:29:07.851]                 is_error <- inherits(cond, "error")
[01:29:07.851]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:07.851]                   NULL)
[01:29:07.851]                 if (is_error) {
[01:29:07.851]                   sessionInformation <- function() {
[01:29:07.851]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:07.851]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:07.851]                       search = base::search(), system = base::Sys.info())
[01:29:07.851]                   }
[01:29:07.851]                   ...future.conditions[[length(...future.conditions) + 
[01:29:07.851]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:07.851]                     cond$call), session = sessionInformation(), 
[01:29:07.851]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:07.851]                   signalCondition(cond)
[01:29:07.851]                 }
[01:29:07.851]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:07.851]                 "immediateCondition"))) {
[01:29:07.851]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:07.851]                   ...future.conditions[[length(...future.conditions) + 
[01:29:07.851]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:07.851]                   if (TRUE && !signal) {
[01:29:07.851]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:07.851]                     {
[01:29:07.851]                       inherits <- base::inherits
[01:29:07.851]                       invokeRestart <- base::invokeRestart
[01:29:07.851]                       is.null <- base::is.null
[01:29:07.851]                       muffled <- FALSE
[01:29:07.851]                       if (inherits(cond, "message")) {
[01:29:07.851]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:07.851]                         if (muffled) 
[01:29:07.851]                           invokeRestart("muffleMessage")
[01:29:07.851]                       }
[01:29:07.851]                       else if (inherits(cond, "warning")) {
[01:29:07.851]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:07.851]                         if (muffled) 
[01:29:07.851]                           invokeRestart("muffleWarning")
[01:29:07.851]                       }
[01:29:07.851]                       else if (inherits(cond, "condition")) {
[01:29:07.851]                         if (!is.null(pattern)) {
[01:29:07.851]                           computeRestarts <- base::computeRestarts
[01:29:07.851]                           grepl <- base::grepl
[01:29:07.851]                           restarts <- computeRestarts(cond)
[01:29:07.851]                           for (restart in restarts) {
[01:29:07.851]                             name <- restart$name
[01:29:07.851]                             if (is.null(name)) 
[01:29:07.851]                               next
[01:29:07.851]                             if (!grepl(pattern, name)) 
[01:29:07.851]                               next
[01:29:07.851]                             invokeRestart(restart)
[01:29:07.851]                             muffled <- TRUE
[01:29:07.851]                             break
[01:29:07.851]                           }
[01:29:07.851]                         }
[01:29:07.851]                       }
[01:29:07.851]                       invisible(muffled)
[01:29:07.851]                     }
[01:29:07.851]                     muffleCondition(cond, pattern = "^muffle")
[01:29:07.851]                   }
[01:29:07.851]                 }
[01:29:07.851]                 else {
[01:29:07.851]                   if (TRUE) {
[01:29:07.851]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:07.851]                     {
[01:29:07.851]                       inherits <- base::inherits
[01:29:07.851]                       invokeRestart <- base::invokeRestart
[01:29:07.851]                       is.null <- base::is.null
[01:29:07.851]                       muffled <- FALSE
[01:29:07.851]                       if (inherits(cond, "message")) {
[01:29:07.851]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:07.851]                         if (muffled) 
[01:29:07.851]                           invokeRestart("muffleMessage")
[01:29:07.851]                       }
[01:29:07.851]                       else if (inherits(cond, "warning")) {
[01:29:07.851]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:07.851]                         if (muffled) 
[01:29:07.851]                           invokeRestart("muffleWarning")
[01:29:07.851]                       }
[01:29:07.851]                       else if (inherits(cond, "condition")) {
[01:29:07.851]                         if (!is.null(pattern)) {
[01:29:07.851]                           computeRestarts <- base::computeRestarts
[01:29:07.851]                           grepl <- base::grepl
[01:29:07.851]                           restarts <- computeRestarts(cond)
[01:29:07.851]                           for (restart in restarts) {
[01:29:07.851]                             name <- restart$name
[01:29:07.851]                             if (is.null(name)) 
[01:29:07.851]                               next
[01:29:07.851]                             if (!grepl(pattern, name)) 
[01:29:07.851]                               next
[01:29:07.851]                             invokeRestart(restart)
[01:29:07.851]                             muffled <- TRUE
[01:29:07.851]                             break
[01:29:07.851]                           }
[01:29:07.851]                         }
[01:29:07.851]                       }
[01:29:07.851]                       invisible(muffled)
[01:29:07.851]                     }
[01:29:07.851]                     muffleCondition(cond, pattern = "^muffle")
[01:29:07.851]                   }
[01:29:07.851]                 }
[01:29:07.851]             }
[01:29:07.851]         }))
[01:29:07.851]     }, error = function(ex) {
[01:29:07.851]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:07.851]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:07.851]                 ...future.rng), started = ...future.startTime, 
[01:29:07.851]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:07.851]             version = "1.8"), class = "FutureResult")
[01:29:07.851]     }, finally = {
[01:29:07.851]         if (!identical(...future.workdir, getwd())) 
[01:29:07.851]             setwd(...future.workdir)
[01:29:07.851]         {
[01:29:07.851]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:07.851]                 ...future.oldOptions$nwarnings <- NULL
[01:29:07.851]             }
[01:29:07.851]             base::options(...future.oldOptions)
[01:29:07.851]             if (.Platform$OS.type == "windows") {
[01:29:07.851]                 old_names <- names(...future.oldEnvVars)
[01:29:07.851]                 envs <- base::Sys.getenv()
[01:29:07.851]                 names <- names(envs)
[01:29:07.851]                 common <- intersect(names, old_names)
[01:29:07.851]                 added <- setdiff(names, old_names)
[01:29:07.851]                 removed <- setdiff(old_names, names)
[01:29:07.851]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:07.851]                   envs[common]]
[01:29:07.851]                 NAMES <- toupper(changed)
[01:29:07.851]                 args <- list()
[01:29:07.851]                 for (kk in seq_along(NAMES)) {
[01:29:07.851]                   name <- changed[[kk]]
[01:29:07.851]                   NAME <- NAMES[[kk]]
[01:29:07.851]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:07.851]                     next
[01:29:07.851]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:07.851]                 }
[01:29:07.851]                 NAMES <- toupper(added)
[01:29:07.851]                 for (kk in seq_along(NAMES)) {
[01:29:07.851]                   name <- added[[kk]]
[01:29:07.851]                   NAME <- NAMES[[kk]]
[01:29:07.851]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:07.851]                     next
[01:29:07.851]                   args[[name]] <- ""
[01:29:07.851]                 }
[01:29:07.851]                 NAMES <- toupper(removed)
[01:29:07.851]                 for (kk in seq_along(NAMES)) {
[01:29:07.851]                   name <- removed[[kk]]
[01:29:07.851]                   NAME <- NAMES[[kk]]
[01:29:07.851]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:07.851]                     next
[01:29:07.851]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:07.851]                 }
[01:29:07.851]                 if (length(args) > 0) 
[01:29:07.851]                   base::do.call(base::Sys.setenv, args = args)
[01:29:07.851]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:07.851]             }
[01:29:07.851]             else {
[01:29:07.851]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:07.851]             }
[01:29:07.851]             {
[01:29:07.851]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:07.851]                   0L) {
[01:29:07.851]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:07.851]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:07.851]                   base::options(opts)
[01:29:07.851]                 }
[01:29:07.851]                 {
[01:29:07.851]                   {
[01:29:07.851]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:07.851]                     NULL
[01:29:07.851]                   }
[01:29:07.851]                   options(future.plan = NULL)
[01:29:07.851]                   if (is.na(NA_character_)) 
[01:29:07.851]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:07.851]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:07.851]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:07.851]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:07.851]                     envir = parent.frame()) 
[01:29:07.851]                   {
[01:29:07.851]                     if (is.function(workers)) 
[01:29:07.851]                       workers <- workers()
[01:29:07.851]                     workers <- structure(as.integer(workers), 
[01:29:07.851]                       class = class(workers))
[01:29:07.851]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:07.851]                       workers >= 1)
[01:29:07.851]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:07.851]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:07.851]                     }
[01:29:07.851]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:07.851]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:07.851]                       envir = envir)
[01:29:07.851]                     if (!future$lazy) 
[01:29:07.851]                       future <- run(future)
[01:29:07.851]                     invisible(future)
[01:29:07.851]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:07.851]                 }
[01:29:07.851]             }
[01:29:07.851]         }
[01:29:07.851]     })
[01:29:07.851]     if (TRUE) {
[01:29:07.851]         base::sink(type = "output", split = FALSE)
[01:29:07.851]         if (TRUE) {
[01:29:07.851]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:07.851]         }
[01:29:07.851]         else {
[01:29:07.851]             ...future.result["stdout"] <- base::list(NULL)
[01:29:07.851]         }
[01:29:07.851]         base::close(...future.stdout)
[01:29:07.851]         ...future.stdout <- NULL
[01:29:07.851]     }
[01:29:07.851]     ...future.result$conditions <- ...future.conditions
[01:29:07.851]     ...future.result$finished <- base::Sys.time()
[01:29:07.851]     ...future.result
[01:29:07.851] }
[01:29:07.857] MultisessionFuture started
[01:29:07.857] - Launch lazy future ... done
[01:29:07.858] run() for 'MultisessionFuture' ... done
[01:29:07.883] receiveMessageFromWorker() for ClusterFuture ...
[01:29:07.883] - Validating connection of MultisessionFuture
[01:29:07.884] - received message: FutureResult
[01:29:07.884] - Received FutureResult
[01:29:07.884] - Erased future from FutureRegistry
[01:29:07.885] result() for ClusterFuture ...
[01:29:07.885] - result already collected: FutureResult
[01:29:07.885] result() for ClusterFuture ... done
[01:29:07.885] signalConditions() ...
[01:29:07.885]  - include = 'immediateCondition'
[01:29:07.885]  - exclude = 
[01:29:07.886]  - resignal = FALSE
[01:29:07.886]  - Number of conditions: 1
[01:29:07.886] signalConditions() ... done
[01:29:07.886] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:07.886] A MultisessionFuture was resolved
[01:29:07.886] getGlobalsAndPackages() ...
[01:29:07.887] Searching for globals...
[01:29:07.887] - globals found: [2] 'list', 'stop'
[01:29:07.888] Searching for globals ... DONE
[01:29:07.888] Resolving globals: FALSE
[01:29:07.888] 
[01:29:07.888] 
[01:29:07.889] getGlobalsAndPackages() ... DONE
[01:29:07.889] run() for 'Future' ...
[01:29:07.889] - state: 'created'
[01:29:07.889] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:07.904] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:07.904] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:07.904]   - Field: 'node'
[01:29:07.904]   - Field: 'label'
[01:29:07.905]   - Field: 'local'
[01:29:07.905]   - Field: 'owner'
[01:29:07.905]   - Field: 'envir'
[01:29:07.905]   - Field: 'workers'
[01:29:07.905]   - Field: 'packages'
[01:29:07.906]   - Field: 'gc'
[01:29:07.906]   - Field: 'conditions'
[01:29:07.906]   - Field: 'persistent'
[01:29:07.906]   - Field: 'expr'
[01:29:07.906]   - Field: 'uuid'
[01:29:07.907]   - Field: 'seed'
[01:29:07.907]   - Field: 'version'
[01:29:07.907]   - Field: 'result'
[01:29:07.907]   - Field: 'asynchronous'
[01:29:07.907]   - Field: 'calls'
[01:29:07.908]   - Field: 'globals'
[01:29:07.908]   - Field: 'stdout'
[01:29:07.908]   - Field: 'earlySignal'
[01:29:07.908]   - Field: 'lazy'
[01:29:07.908]   - Field: 'state'
[01:29:07.908] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:07.909] - Launch lazy future ...
[01:29:07.909] Packages needed by the future expression (n = 0): <none>
[01:29:07.909] Packages needed by future strategies (n = 0): <none>
[01:29:07.913] {
[01:29:07.913]     {
[01:29:07.913]         {
[01:29:07.913]             ...future.startTime <- base::Sys.time()
[01:29:07.913]             {
[01:29:07.913]                 {
[01:29:07.913]                   {
[01:29:07.913]                     {
[01:29:07.913]                       base::local({
[01:29:07.913]                         has_future <- base::requireNamespace("future", 
[01:29:07.913]                           quietly = TRUE)
[01:29:07.913]                         if (has_future) {
[01:29:07.913]                           ns <- base::getNamespace("future")
[01:29:07.913]                           version <- ns[[".package"]][["version"]]
[01:29:07.913]                           if (is.null(version)) 
[01:29:07.913]                             version <- utils::packageVersion("future")
[01:29:07.913]                         }
[01:29:07.913]                         else {
[01:29:07.913]                           version <- NULL
[01:29:07.913]                         }
[01:29:07.913]                         if (!has_future || version < "1.8.0") {
[01:29:07.913]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:07.913]                             "", base::R.version$version.string), 
[01:29:07.913]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:07.913]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:07.913]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:07.913]                               "release", "version")], collapse = " "), 
[01:29:07.913]                             hostname = base::Sys.info()[["nodename"]])
[01:29:07.913]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:07.913]                             info)
[01:29:07.913]                           info <- base::paste(info, collapse = "; ")
[01:29:07.913]                           if (!has_future) {
[01:29:07.913]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:07.913]                               info)
[01:29:07.913]                           }
[01:29:07.913]                           else {
[01:29:07.913]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:07.913]                               info, version)
[01:29:07.913]                           }
[01:29:07.913]                           base::stop(msg)
[01:29:07.913]                         }
[01:29:07.913]                       })
[01:29:07.913]                     }
[01:29:07.913]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:07.913]                     base::options(mc.cores = 1L)
[01:29:07.913]                   }
[01:29:07.913]                   options(future.plan = NULL)
[01:29:07.913]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:07.913]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:07.913]                 }
[01:29:07.913]                 ...future.workdir <- getwd()
[01:29:07.913]             }
[01:29:07.913]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:07.913]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:07.913]         }
[01:29:07.913]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:07.913]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:07.913]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:07.913]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:07.913]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:07.913]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:07.913]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:07.913]             base::names(...future.oldOptions))
[01:29:07.913]     }
[01:29:07.913]     if (FALSE) {
[01:29:07.913]     }
[01:29:07.913]     else {
[01:29:07.913]         if (TRUE) {
[01:29:07.913]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:07.913]                 open = "w")
[01:29:07.913]         }
[01:29:07.913]         else {
[01:29:07.913]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:07.913]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:07.913]         }
[01:29:07.913]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:07.913]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:07.913]             base::sink(type = "output", split = FALSE)
[01:29:07.913]             base::close(...future.stdout)
[01:29:07.913]         }, add = TRUE)
[01:29:07.913]     }
[01:29:07.913]     ...future.frame <- base::sys.nframe()
[01:29:07.913]     ...future.conditions <- base::list()
[01:29:07.913]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:07.913]     if (FALSE) {
[01:29:07.913]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:07.913]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:07.913]     }
[01:29:07.913]     ...future.result <- base::tryCatch({
[01:29:07.913]         base::withCallingHandlers({
[01:29:07.913]             ...future.value <- base::withVisible(base::local({
[01:29:07.913]                 ...future.makeSendCondition <- base::local({
[01:29:07.913]                   sendCondition <- NULL
[01:29:07.913]                   function(frame = 1L) {
[01:29:07.913]                     if (is.function(sendCondition)) 
[01:29:07.913]                       return(sendCondition)
[01:29:07.913]                     ns <- getNamespace("parallel")
[01:29:07.913]                     if (exists("sendData", mode = "function", 
[01:29:07.913]                       envir = ns)) {
[01:29:07.913]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:07.913]                         envir = ns)
[01:29:07.913]                       envir <- sys.frame(frame)
[01:29:07.913]                       master <- NULL
[01:29:07.913]                       while (!identical(envir, .GlobalEnv) && 
[01:29:07.913]                         !identical(envir, emptyenv())) {
[01:29:07.913]                         if (exists("master", mode = "list", envir = envir, 
[01:29:07.913]                           inherits = FALSE)) {
[01:29:07.913]                           master <- get("master", mode = "list", 
[01:29:07.913]                             envir = envir, inherits = FALSE)
[01:29:07.913]                           if (inherits(master, c("SOCKnode", 
[01:29:07.913]                             "SOCK0node"))) {
[01:29:07.913]                             sendCondition <<- function(cond) {
[01:29:07.913]                               data <- list(type = "VALUE", value = cond, 
[01:29:07.913]                                 success = TRUE)
[01:29:07.913]                               parallel_sendData(master, data)
[01:29:07.913]                             }
[01:29:07.913]                             return(sendCondition)
[01:29:07.913]                           }
[01:29:07.913]                         }
[01:29:07.913]                         frame <- frame + 1L
[01:29:07.913]                         envir <- sys.frame(frame)
[01:29:07.913]                       }
[01:29:07.913]                     }
[01:29:07.913]                     sendCondition <<- function(cond) NULL
[01:29:07.913]                   }
[01:29:07.913]                 })
[01:29:07.913]                 withCallingHandlers({
[01:29:07.913]                   list(a = 1, b = 42L, c = stop("Nah!"))
[01:29:07.913]                 }, immediateCondition = function(cond) {
[01:29:07.913]                   sendCondition <- ...future.makeSendCondition()
[01:29:07.913]                   sendCondition(cond)
[01:29:07.913]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:07.913]                   {
[01:29:07.913]                     inherits <- base::inherits
[01:29:07.913]                     invokeRestart <- base::invokeRestart
[01:29:07.913]                     is.null <- base::is.null
[01:29:07.913]                     muffled <- FALSE
[01:29:07.913]                     if (inherits(cond, "message")) {
[01:29:07.913]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:07.913]                       if (muffled) 
[01:29:07.913]                         invokeRestart("muffleMessage")
[01:29:07.913]                     }
[01:29:07.913]                     else if (inherits(cond, "warning")) {
[01:29:07.913]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:07.913]                       if (muffled) 
[01:29:07.913]                         invokeRestart("muffleWarning")
[01:29:07.913]                     }
[01:29:07.913]                     else if (inherits(cond, "condition")) {
[01:29:07.913]                       if (!is.null(pattern)) {
[01:29:07.913]                         computeRestarts <- base::computeRestarts
[01:29:07.913]                         grepl <- base::grepl
[01:29:07.913]                         restarts <- computeRestarts(cond)
[01:29:07.913]                         for (restart in restarts) {
[01:29:07.913]                           name <- restart$name
[01:29:07.913]                           if (is.null(name)) 
[01:29:07.913]                             next
[01:29:07.913]                           if (!grepl(pattern, name)) 
[01:29:07.913]                             next
[01:29:07.913]                           invokeRestart(restart)
[01:29:07.913]                           muffled <- TRUE
[01:29:07.913]                           break
[01:29:07.913]                         }
[01:29:07.913]                       }
[01:29:07.913]                     }
[01:29:07.913]                     invisible(muffled)
[01:29:07.913]                   }
[01:29:07.913]                   muffleCondition(cond)
[01:29:07.913]                 })
[01:29:07.913]             }))
[01:29:07.913]             future::FutureResult(value = ...future.value$value, 
[01:29:07.913]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:07.913]                   ...future.rng), globalenv = if (FALSE) 
[01:29:07.913]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:07.913]                     ...future.globalenv.names))
[01:29:07.913]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:07.913]         }, condition = base::local({
[01:29:07.913]             c <- base::c
[01:29:07.913]             inherits <- base::inherits
[01:29:07.913]             invokeRestart <- base::invokeRestart
[01:29:07.913]             length <- base::length
[01:29:07.913]             list <- base::list
[01:29:07.913]             seq.int <- base::seq.int
[01:29:07.913]             signalCondition <- base::signalCondition
[01:29:07.913]             sys.calls <- base::sys.calls
[01:29:07.913]             `[[` <- base::`[[`
[01:29:07.913]             `+` <- base::`+`
[01:29:07.913]             `<<-` <- base::`<<-`
[01:29:07.913]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:07.913]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:07.913]                   3L)]
[01:29:07.913]             }
[01:29:07.913]             function(cond) {
[01:29:07.913]                 is_error <- inherits(cond, "error")
[01:29:07.913]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:07.913]                   NULL)
[01:29:07.913]                 if (is_error) {
[01:29:07.913]                   sessionInformation <- function() {
[01:29:07.913]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:07.913]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:07.913]                       search = base::search(), system = base::Sys.info())
[01:29:07.913]                   }
[01:29:07.913]                   ...future.conditions[[length(...future.conditions) + 
[01:29:07.913]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:07.913]                     cond$call), session = sessionInformation(), 
[01:29:07.913]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:07.913]                   signalCondition(cond)
[01:29:07.913]                 }
[01:29:07.913]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:07.913]                 "immediateCondition"))) {
[01:29:07.913]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:07.913]                   ...future.conditions[[length(...future.conditions) + 
[01:29:07.913]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:07.913]                   if (TRUE && !signal) {
[01:29:07.913]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:07.913]                     {
[01:29:07.913]                       inherits <- base::inherits
[01:29:07.913]                       invokeRestart <- base::invokeRestart
[01:29:07.913]                       is.null <- base::is.null
[01:29:07.913]                       muffled <- FALSE
[01:29:07.913]                       if (inherits(cond, "message")) {
[01:29:07.913]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:07.913]                         if (muffled) 
[01:29:07.913]                           invokeRestart("muffleMessage")
[01:29:07.913]                       }
[01:29:07.913]                       else if (inherits(cond, "warning")) {
[01:29:07.913]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:07.913]                         if (muffled) 
[01:29:07.913]                           invokeRestart("muffleWarning")
[01:29:07.913]                       }
[01:29:07.913]                       else if (inherits(cond, "condition")) {
[01:29:07.913]                         if (!is.null(pattern)) {
[01:29:07.913]                           computeRestarts <- base::computeRestarts
[01:29:07.913]                           grepl <- base::grepl
[01:29:07.913]                           restarts <- computeRestarts(cond)
[01:29:07.913]                           for (restart in restarts) {
[01:29:07.913]                             name <- restart$name
[01:29:07.913]                             if (is.null(name)) 
[01:29:07.913]                               next
[01:29:07.913]                             if (!grepl(pattern, name)) 
[01:29:07.913]                               next
[01:29:07.913]                             invokeRestart(restart)
[01:29:07.913]                             muffled <- TRUE
[01:29:07.913]                             break
[01:29:07.913]                           }
[01:29:07.913]                         }
[01:29:07.913]                       }
[01:29:07.913]                       invisible(muffled)
[01:29:07.913]                     }
[01:29:07.913]                     muffleCondition(cond, pattern = "^muffle")
[01:29:07.913]                   }
[01:29:07.913]                 }
[01:29:07.913]                 else {
[01:29:07.913]                   if (TRUE) {
[01:29:07.913]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:07.913]                     {
[01:29:07.913]                       inherits <- base::inherits
[01:29:07.913]                       invokeRestart <- base::invokeRestart
[01:29:07.913]                       is.null <- base::is.null
[01:29:07.913]                       muffled <- FALSE
[01:29:07.913]                       if (inherits(cond, "message")) {
[01:29:07.913]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:07.913]                         if (muffled) 
[01:29:07.913]                           invokeRestart("muffleMessage")
[01:29:07.913]                       }
[01:29:07.913]                       else if (inherits(cond, "warning")) {
[01:29:07.913]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:07.913]                         if (muffled) 
[01:29:07.913]                           invokeRestart("muffleWarning")
[01:29:07.913]                       }
[01:29:07.913]                       else if (inherits(cond, "condition")) {
[01:29:07.913]                         if (!is.null(pattern)) {
[01:29:07.913]                           computeRestarts <- base::computeRestarts
[01:29:07.913]                           grepl <- base::grepl
[01:29:07.913]                           restarts <- computeRestarts(cond)
[01:29:07.913]                           for (restart in restarts) {
[01:29:07.913]                             name <- restart$name
[01:29:07.913]                             if (is.null(name)) 
[01:29:07.913]                               next
[01:29:07.913]                             if (!grepl(pattern, name)) 
[01:29:07.913]                               next
[01:29:07.913]                             invokeRestart(restart)
[01:29:07.913]                             muffled <- TRUE
[01:29:07.913]                             break
[01:29:07.913]                           }
[01:29:07.913]                         }
[01:29:07.913]                       }
[01:29:07.913]                       invisible(muffled)
[01:29:07.913]                     }
[01:29:07.913]                     muffleCondition(cond, pattern = "^muffle")
[01:29:07.913]                   }
[01:29:07.913]                 }
[01:29:07.913]             }
[01:29:07.913]         }))
[01:29:07.913]     }, error = function(ex) {
[01:29:07.913]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:07.913]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:07.913]                 ...future.rng), started = ...future.startTime, 
[01:29:07.913]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:07.913]             version = "1.8"), class = "FutureResult")
[01:29:07.913]     }, finally = {
[01:29:07.913]         if (!identical(...future.workdir, getwd())) 
[01:29:07.913]             setwd(...future.workdir)
[01:29:07.913]         {
[01:29:07.913]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:07.913]                 ...future.oldOptions$nwarnings <- NULL
[01:29:07.913]             }
[01:29:07.913]             base::options(...future.oldOptions)
[01:29:07.913]             if (.Platform$OS.type == "windows") {
[01:29:07.913]                 old_names <- names(...future.oldEnvVars)
[01:29:07.913]                 envs <- base::Sys.getenv()
[01:29:07.913]                 names <- names(envs)
[01:29:07.913]                 common <- intersect(names, old_names)
[01:29:07.913]                 added <- setdiff(names, old_names)
[01:29:07.913]                 removed <- setdiff(old_names, names)
[01:29:07.913]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:07.913]                   envs[common]]
[01:29:07.913]                 NAMES <- toupper(changed)
[01:29:07.913]                 args <- list()
[01:29:07.913]                 for (kk in seq_along(NAMES)) {
[01:29:07.913]                   name <- changed[[kk]]
[01:29:07.913]                   NAME <- NAMES[[kk]]
[01:29:07.913]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:07.913]                     next
[01:29:07.913]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:07.913]                 }
[01:29:07.913]                 NAMES <- toupper(added)
[01:29:07.913]                 for (kk in seq_along(NAMES)) {
[01:29:07.913]                   name <- added[[kk]]
[01:29:07.913]                   NAME <- NAMES[[kk]]
[01:29:07.913]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:07.913]                     next
[01:29:07.913]                   args[[name]] <- ""
[01:29:07.913]                 }
[01:29:07.913]                 NAMES <- toupper(removed)
[01:29:07.913]                 for (kk in seq_along(NAMES)) {
[01:29:07.913]                   name <- removed[[kk]]
[01:29:07.913]                   NAME <- NAMES[[kk]]
[01:29:07.913]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:07.913]                     next
[01:29:07.913]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:07.913]                 }
[01:29:07.913]                 if (length(args) > 0) 
[01:29:07.913]                   base::do.call(base::Sys.setenv, args = args)
[01:29:07.913]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:07.913]             }
[01:29:07.913]             else {
[01:29:07.913]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:07.913]             }
[01:29:07.913]             {
[01:29:07.913]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:07.913]                   0L) {
[01:29:07.913]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:07.913]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:07.913]                   base::options(opts)
[01:29:07.913]                 }
[01:29:07.913]                 {
[01:29:07.913]                   {
[01:29:07.913]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:07.913]                     NULL
[01:29:07.913]                   }
[01:29:07.913]                   options(future.plan = NULL)
[01:29:07.913]                   if (is.na(NA_character_)) 
[01:29:07.913]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:07.913]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:07.913]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:07.913]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:07.913]                     envir = parent.frame()) 
[01:29:07.913]                   {
[01:29:07.913]                     if (is.function(workers)) 
[01:29:07.913]                       workers <- workers()
[01:29:07.913]                     workers <- structure(as.integer(workers), 
[01:29:07.913]                       class = class(workers))
[01:29:07.913]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:07.913]                       workers >= 1)
[01:29:07.913]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:07.913]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:07.913]                     }
[01:29:07.913]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:07.913]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:07.913]                       envir = envir)
[01:29:07.913]                     if (!future$lazy) 
[01:29:07.913]                       future <- run(future)
[01:29:07.913]                     invisible(future)
[01:29:07.913]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:07.913]                 }
[01:29:07.913]             }
[01:29:07.913]         }
[01:29:07.913]     })
[01:29:07.913]     if (TRUE) {
[01:29:07.913]         base::sink(type = "output", split = FALSE)
[01:29:07.913]         if (TRUE) {
[01:29:07.913]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:07.913]         }
[01:29:07.913]         else {
[01:29:07.913]             ...future.result["stdout"] <- base::list(NULL)
[01:29:07.913]         }
[01:29:07.913]         base::close(...future.stdout)
[01:29:07.913]         ...future.stdout <- NULL
[01:29:07.913]     }
[01:29:07.913]     ...future.result$conditions <- ...future.conditions
[01:29:07.913]     ...future.result$finished <- base::Sys.time()
[01:29:07.913]     ...future.result
[01:29:07.913] }
[01:29:07.919] MultisessionFuture started
[01:29:07.919] - Launch lazy future ... done
[01:29:07.919] run() for 'MultisessionFuture' ... done
[01:29:07.942] receiveMessageFromWorker() for ClusterFuture ...
[01:29:07.943] - Validating connection of MultisessionFuture
[01:29:07.943] - received message: FutureResult
[01:29:07.943] - Received FutureResult
[01:29:07.944] - Erased future from FutureRegistry
[01:29:07.944] result() for ClusterFuture ...
[01:29:07.944] - result already collected: FutureResult
[01:29:07.944] result() for ClusterFuture ... done
[01:29:07.944] signalConditions() ...
[01:29:07.944]  - include = 'immediateCondition'
[01:29:07.945]  - exclude = 
[01:29:07.945]  - resignal = FALSE
[01:29:07.945]  - Number of conditions: 1
[01:29:07.945] signalConditions() ... done
[01:29:07.945] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:07.945] A MultisessionFuture was resolved
- result = TRUE, recursive = 0 ... DONE
- result = TRUE, recursive = 1 ...
[01:29:07.946] getGlobalsAndPackages() ...
[01:29:07.946] Searching for globals...
[01:29:07.947] - globals found: [3] '{', 'Sys.sleep', 'list'
[01:29:07.948] Searching for globals ... DONE
[01:29:07.948] Resolving globals: FALSE
[01:29:07.948] 
[01:29:07.948] 
[01:29:07.949] getGlobalsAndPackages() ... DONE
[01:29:07.949] run() for 'Future' ...
[01:29:07.949] - state: 'created'
[01:29:07.949] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:07.964] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:07.964] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:07.965]   - Field: 'node'
[01:29:07.965]   - Field: 'label'
[01:29:07.965]   - Field: 'local'
[01:29:07.965]   - Field: 'owner'
[01:29:07.965]   - Field: 'envir'
[01:29:07.965]   - Field: 'workers'
[01:29:07.966]   - Field: 'packages'
[01:29:07.966]   - Field: 'gc'
[01:29:07.966]   - Field: 'conditions'
[01:29:07.966]   - Field: 'persistent'
[01:29:07.966]   - Field: 'expr'
[01:29:07.967]   - Field: 'uuid'
[01:29:07.967]   - Field: 'seed'
[01:29:07.967]   - Field: 'version'
[01:29:07.967]   - Field: 'result'
[01:29:07.967]   - Field: 'asynchronous'
[01:29:07.967]   - Field: 'calls'
[01:29:07.968]   - Field: 'globals'
[01:29:07.968]   - Field: 'stdout'
[01:29:07.968]   - Field: 'earlySignal'
[01:29:07.968]   - Field: 'lazy'
[01:29:07.968]   - Field: 'state'
[01:29:07.968] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:07.969] - Launch lazy future ...
[01:29:07.969] Packages needed by the future expression (n = 0): <none>
[01:29:07.969] Packages needed by future strategies (n = 0): <none>
[01:29:07.970] {
[01:29:07.970]     {
[01:29:07.970]         {
[01:29:07.970]             ...future.startTime <- base::Sys.time()
[01:29:07.970]             {
[01:29:07.970]                 {
[01:29:07.970]                   {
[01:29:07.970]                     {
[01:29:07.970]                       base::local({
[01:29:07.970]                         has_future <- base::requireNamespace("future", 
[01:29:07.970]                           quietly = TRUE)
[01:29:07.970]                         if (has_future) {
[01:29:07.970]                           ns <- base::getNamespace("future")
[01:29:07.970]                           version <- ns[[".package"]][["version"]]
[01:29:07.970]                           if (is.null(version)) 
[01:29:07.970]                             version <- utils::packageVersion("future")
[01:29:07.970]                         }
[01:29:07.970]                         else {
[01:29:07.970]                           version <- NULL
[01:29:07.970]                         }
[01:29:07.970]                         if (!has_future || version < "1.8.0") {
[01:29:07.970]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:07.970]                             "", base::R.version$version.string), 
[01:29:07.970]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:07.970]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:07.970]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:07.970]                               "release", "version")], collapse = " "), 
[01:29:07.970]                             hostname = base::Sys.info()[["nodename"]])
[01:29:07.970]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:07.970]                             info)
[01:29:07.970]                           info <- base::paste(info, collapse = "; ")
[01:29:07.970]                           if (!has_future) {
[01:29:07.970]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:07.970]                               info)
[01:29:07.970]                           }
[01:29:07.970]                           else {
[01:29:07.970]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:07.970]                               info, version)
[01:29:07.970]                           }
[01:29:07.970]                           base::stop(msg)
[01:29:07.970]                         }
[01:29:07.970]                       })
[01:29:07.970]                     }
[01:29:07.970]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:07.970]                     base::options(mc.cores = 1L)
[01:29:07.970]                   }
[01:29:07.970]                   options(future.plan = NULL)
[01:29:07.970]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:07.970]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:07.970]                 }
[01:29:07.970]                 ...future.workdir <- getwd()
[01:29:07.970]             }
[01:29:07.970]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:07.970]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:07.970]         }
[01:29:07.970]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:07.970]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:07.970]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:07.970]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:07.970]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:07.970]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:07.970]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:07.970]             base::names(...future.oldOptions))
[01:29:07.970]     }
[01:29:07.970]     if (FALSE) {
[01:29:07.970]     }
[01:29:07.970]     else {
[01:29:07.970]         if (TRUE) {
[01:29:07.970]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:07.970]                 open = "w")
[01:29:07.970]         }
[01:29:07.970]         else {
[01:29:07.970]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:07.970]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:07.970]         }
[01:29:07.970]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:07.970]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:07.970]             base::sink(type = "output", split = FALSE)
[01:29:07.970]             base::close(...future.stdout)
[01:29:07.970]         }, add = TRUE)
[01:29:07.970]     }
[01:29:07.970]     ...future.frame <- base::sys.nframe()
[01:29:07.970]     ...future.conditions <- base::list()
[01:29:07.970]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:07.970]     if (FALSE) {
[01:29:07.970]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:07.970]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:07.970]     }
[01:29:07.970]     ...future.result <- base::tryCatch({
[01:29:07.970]         base::withCallingHandlers({
[01:29:07.970]             ...future.value <- base::withVisible(base::local({
[01:29:07.970]                 ...future.makeSendCondition <- base::local({
[01:29:07.970]                   sendCondition <- NULL
[01:29:07.970]                   function(frame = 1L) {
[01:29:07.970]                     if (is.function(sendCondition)) 
[01:29:07.970]                       return(sendCondition)
[01:29:07.970]                     ns <- getNamespace("parallel")
[01:29:07.970]                     if (exists("sendData", mode = "function", 
[01:29:07.970]                       envir = ns)) {
[01:29:07.970]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:07.970]                         envir = ns)
[01:29:07.970]                       envir <- sys.frame(frame)
[01:29:07.970]                       master <- NULL
[01:29:07.970]                       while (!identical(envir, .GlobalEnv) && 
[01:29:07.970]                         !identical(envir, emptyenv())) {
[01:29:07.970]                         if (exists("master", mode = "list", envir = envir, 
[01:29:07.970]                           inherits = FALSE)) {
[01:29:07.970]                           master <- get("master", mode = "list", 
[01:29:07.970]                             envir = envir, inherits = FALSE)
[01:29:07.970]                           if (inherits(master, c("SOCKnode", 
[01:29:07.970]                             "SOCK0node"))) {
[01:29:07.970]                             sendCondition <<- function(cond) {
[01:29:07.970]                               data <- list(type = "VALUE", value = cond, 
[01:29:07.970]                                 success = TRUE)
[01:29:07.970]                               parallel_sendData(master, data)
[01:29:07.970]                             }
[01:29:07.970]                             return(sendCondition)
[01:29:07.970]                           }
[01:29:07.970]                         }
[01:29:07.970]                         frame <- frame + 1L
[01:29:07.970]                         envir <- sys.frame(frame)
[01:29:07.970]                       }
[01:29:07.970]                     }
[01:29:07.970]                     sendCondition <<- function(cond) NULL
[01:29:07.970]                   }
[01:29:07.970]                 })
[01:29:07.970]                 withCallingHandlers({
[01:29:07.970]                   {
[01:29:07.970]                     Sys.sleep(0.5)
[01:29:07.970]                     list(a = 1, b = 42L)
[01:29:07.970]                   }
[01:29:07.970]                 }, immediateCondition = function(cond) {
[01:29:07.970]                   sendCondition <- ...future.makeSendCondition()
[01:29:07.970]                   sendCondition(cond)
[01:29:07.970]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:07.970]                   {
[01:29:07.970]                     inherits <- base::inherits
[01:29:07.970]                     invokeRestart <- base::invokeRestart
[01:29:07.970]                     is.null <- base::is.null
[01:29:07.970]                     muffled <- FALSE
[01:29:07.970]                     if (inherits(cond, "message")) {
[01:29:07.970]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:07.970]                       if (muffled) 
[01:29:07.970]                         invokeRestart("muffleMessage")
[01:29:07.970]                     }
[01:29:07.970]                     else if (inherits(cond, "warning")) {
[01:29:07.970]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:07.970]                       if (muffled) 
[01:29:07.970]                         invokeRestart("muffleWarning")
[01:29:07.970]                     }
[01:29:07.970]                     else if (inherits(cond, "condition")) {
[01:29:07.970]                       if (!is.null(pattern)) {
[01:29:07.970]                         computeRestarts <- base::computeRestarts
[01:29:07.970]                         grepl <- base::grepl
[01:29:07.970]                         restarts <- computeRestarts(cond)
[01:29:07.970]                         for (restart in restarts) {
[01:29:07.970]                           name <- restart$name
[01:29:07.970]                           if (is.null(name)) 
[01:29:07.970]                             next
[01:29:07.970]                           if (!grepl(pattern, name)) 
[01:29:07.970]                             next
[01:29:07.970]                           invokeRestart(restart)
[01:29:07.970]                           muffled <- TRUE
[01:29:07.970]                           break
[01:29:07.970]                         }
[01:29:07.970]                       }
[01:29:07.970]                     }
[01:29:07.970]                     invisible(muffled)
[01:29:07.970]                   }
[01:29:07.970]                   muffleCondition(cond)
[01:29:07.970]                 })
[01:29:07.970]             }))
[01:29:07.970]             future::FutureResult(value = ...future.value$value, 
[01:29:07.970]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:07.970]                   ...future.rng), globalenv = if (FALSE) 
[01:29:07.970]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:07.970]                     ...future.globalenv.names))
[01:29:07.970]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:07.970]         }, condition = base::local({
[01:29:07.970]             c <- base::c
[01:29:07.970]             inherits <- base::inherits
[01:29:07.970]             invokeRestart <- base::invokeRestart
[01:29:07.970]             length <- base::length
[01:29:07.970]             list <- base::list
[01:29:07.970]             seq.int <- base::seq.int
[01:29:07.970]             signalCondition <- base::signalCondition
[01:29:07.970]             sys.calls <- base::sys.calls
[01:29:07.970]             `[[` <- base::`[[`
[01:29:07.970]             `+` <- base::`+`
[01:29:07.970]             `<<-` <- base::`<<-`
[01:29:07.970]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:07.970]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:07.970]                   3L)]
[01:29:07.970]             }
[01:29:07.970]             function(cond) {
[01:29:07.970]                 is_error <- inherits(cond, "error")
[01:29:07.970]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:07.970]                   NULL)
[01:29:07.970]                 if (is_error) {
[01:29:07.970]                   sessionInformation <- function() {
[01:29:07.970]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:07.970]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:07.970]                       search = base::search(), system = base::Sys.info())
[01:29:07.970]                   }
[01:29:07.970]                   ...future.conditions[[length(...future.conditions) + 
[01:29:07.970]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:07.970]                     cond$call), session = sessionInformation(), 
[01:29:07.970]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:07.970]                   signalCondition(cond)
[01:29:07.970]                 }
[01:29:07.970]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:07.970]                 "immediateCondition"))) {
[01:29:07.970]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:07.970]                   ...future.conditions[[length(...future.conditions) + 
[01:29:07.970]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:07.970]                   if (TRUE && !signal) {
[01:29:07.970]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:07.970]                     {
[01:29:07.970]                       inherits <- base::inherits
[01:29:07.970]                       invokeRestart <- base::invokeRestart
[01:29:07.970]                       is.null <- base::is.null
[01:29:07.970]                       muffled <- FALSE
[01:29:07.970]                       if (inherits(cond, "message")) {
[01:29:07.970]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:07.970]                         if (muffled) 
[01:29:07.970]                           invokeRestart("muffleMessage")
[01:29:07.970]                       }
[01:29:07.970]                       else if (inherits(cond, "warning")) {
[01:29:07.970]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:07.970]                         if (muffled) 
[01:29:07.970]                           invokeRestart("muffleWarning")
[01:29:07.970]                       }
[01:29:07.970]                       else if (inherits(cond, "condition")) {
[01:29:07.970]                         if (!is.null(pattern)) {
[01:29:07.970]                           computeRestarts <- base::computeRestarts
[01:29:07.970]                           grepl <- base::grepl
[01:29:07.970]                           restarts <- computeRestarts(cond)
[01:29:07.970]                           for (restart in restarts) {
[01:29:07.970]                             name <- restart$name
[01:29:07.970]                             if (is.null(name)) 
[01:29:07.970]                               next
[01:29:07.970]                             if (!grepl(pattern, name)) 
[01:29:07.970]                               next
[01:29:07.970]                             invokeRestart(restart)
[01:29:07.970]                             muffled <- TRUE
[01:29:07.970]                             break
[01:29:07.970]                           }
[01:29:07.970]                         }
[01:29:07.970]                       }
[01:29:07.970]                       invisible(muffled)
[01:29:07.970]                     }
[01:29:07.970]                     muffleCondition(cond, pattern = "^muffle")
[01:29:07.970]                   }
[01:29:07.970]                 }
[01:29:07.970]                 else {
[01:29:07.970]                   if (TRUE) {
[01:29:07.970]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:07.970]                     {
[01:29:07.970]                       inherits <- base::inherits
[01:29:07.970]                       invokeRestart <- base::invokeRestart
[01:29:07.970]                       is.null <- base::is.null
[01:29:07.970]                       muffled <- FALSE
[01:29:07.970]                       if (inherits(cond, "message")) {
[01:29:07.970]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:07.970]                         if (muffled) 
[01:29:07.970]                           invokeRestart("muffleMessage")
[01:29:07.970]                       }
[01:29:07.970]                       else if (inherits(cond, "warning")) {
[01:29:07.970]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:07.970]                         if (muffled) 
[01:29:07.970]                           invokeRestart("muffleWarning")
[01:29:07.970]                       }
[01:29:07.970]                       else if (inherits(cond, "condition")) {
[01:29:07.970]                         if (!is.null(pattern)) {
[01:29:07.970]                           computeRestarts <- base::computeRestarts
[01:29:07.970]                           grepl <- base::grepl
[01:29:07.970]                           restarts <- computeRestarts(cond)
[01:29:07.970]                           for (restart in restarts) {
[01:29:07.970]                             name <- restart$name
[01:29:07.970]                             if (is.null(name)) 
[01:29:07.970]                               next
[01:29:07.970]                             if (!grepl(pattern, name)) 
[01:29:07.970]                               next
[01:29:07.970]                             invokeRestart(restart)
[01:29:07.970]                             muffled <- TRUE
[01:29:07.970]                             break
[01:29:07.970]                           }
[01:29:07.970]                         }
[01:29:07.970]                       }
[01:29:07.970]                       invisible(muffled)
[01:29:07.970]                     }
[01:29:07.970]                     muffleCondition(cond, pattern = "^muffle")
[01:29:07.970]                   }
[01:29:07.970]                 }
[01:29:07.970]             }
[01:29:07.970]         }))
[01:29:07.970]     }, error = function(ex) {
[01:29:07.970]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:07.970]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:07.970]                 ...future.rng), started = ...future.startTime, 
[01:29:07.970]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:07.970]             version = "1.8"), class = "FutureResult")
[01:29:07.970]     }, finally = {
[01:29:07.970]         if (!identical(...future.workdir, getwd())) 
[01:29:07.970]             setwd(...future.workdir)
[01:29:07.970]         {
[01:29:07.970]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:07.970]                 ...future.oldOptions$nwarnings <- NULL
[01:29:07.970]             }
[01:29:07.970]             base::options(...future.oldOptions)
[01:29:07.970]             if (.Platform$OS.type == "windows") {
[01:29:07.970]                 old_names <- names(...future.oldEnvVars)
[01:29:07.970]                 envs <- base::Sys.getenv()
[01:29:07.970]                 names <- names(envs)
[01:29:07.970]                 common <- intersect(names, old_names)
[01:29:07.970]                 added <- setdiff(names, old_names)
[01:29:07.970]                 removed <- setdiff(old_names, names)
[01:29:07.970]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:07.970]                   envs[common]]
[01:29:07.970]                 NAMES <- toupper(changed)
[01:29:07.970]                 args <- list()
[01:29:07.970]                 for (kk in seq_along(NAMES)) {
[01:29:07.970]                   name <- changed[[kk]]
[01:29:07.970]                   NAME <- NAMES[[kk]]
[01:29:07.970]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:07.970]                     next
[01:29:07.970]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:07.970]                 }
[01:29:07.970]                 NAMES <- toupper(added)
[01:29:07.970]                 for (kk in seq_along(NAMES)) {
[01:29:07.970]                   name <- added[[kk]]
[01:29:07.970]                   NAME <- NAMES[[kk]]
[01:29:07.970]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:07.970]                     next
[01:29:07.970]                   args[[name]] <- ""
[01:29:07.970]                 }
[01:29:07.970]                 NAMES <- toupper(removed)
[01:29:07.970]                 for (kk in seq_along(NAMES)) {
[01:29:07.970]                   name <- removed[[kk]]
[01:29:07.970]                   NAME <- NAMES[[kk]]
[01:29:07.970]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:07.970]                     next
[01:29:07.970]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:07.970]                 }
[01:29:07.970]                 if (length(args) > 0) 
[01:29:07.970]                   base::do.call(base::Sys.setenv, args = args)
[01:29:07.970]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:07.970]             }
[01:29:07.970]             else {
[01:29:07.970]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:07.970]             }
[01:29:07.970]             {
[01:29:07.970]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:07.970]                   0L) {
[01:29:07.970]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:07.970]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:07.970]                   base::options(opts)
[01:29:07.970]                 }
[01:29:07.970]                 {
[01:29:07.970]                   {
[01:29:07.970]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:07.970]                     NULL
[01:29:07.970]                   }
[01:29:07.970]                   options(future.plan = NULL)
[01:29:07.970]                   if (is.na(NA_character_)) 
[01:29:07.970]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:07.970]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:07.970]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:07.970]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:07.970]                     envir = parent.frame()) 
[01:29:07.970]                   {
[01:29:07.970]                     if (is.function(workers)) 
[01:29:07.970]                       workers <- workers()
[01:29:07.970]                     workers <- structure(as.integer(workers), 
[01:29:07.970]                       class = class(workers))
[01:29:07.970]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:07.970]                       workers >= 1)
[01:29:07.970]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:07.970]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:07.970]                     }
[01:29:07.970]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:07.970]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:07.970]                       envir = envir)
[01:29:07.970]                     if (!future$lazy) 
[01:29:07.970]                       future <- run(future)
[01:29:07.970]                     invisible(future)
[01:29:07.970]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:07.970]                 }
[01:29:07.970]             }
[01:29:07.970]         }
[01:29:07.970]     })
[01:29:07.970]     if (TRUE) {
[01:29:07.970]         base::sink(type = "output", split = FALSE)
[01:29:07.970]         if (TRUE) {
[01:29:07.970]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:07.970]         }
[01:29:07.970]         else {
[01:29:07.970]             ...future.result["stdout"] <- base::list(NULL)
[01:29:07.970]         }
[01:29:07.970]         base::close(...future.stdout)
[01:29:07.970]         ...future.stdout <- NULL
[01:29:07.970]     }
[01:29:07.970]     ...future.result$conditions <- ...future.conditions
[01:29:07.970]     ...future.result$finished <- base::Sys.time()
[01:29:07.970]     ...future.result
[01:29:07.970] }
[01:29:07.976] MultisessionFuture started
[01:29:07.976] - Launch lazy future ... done
[01:29:07.976] run() for 'MultisessionFuture' ... done
[01:29:08.505] receiveMessageFromWorker() for ClusterFuture ...
[01:29:08.506] - Validating connection of MultisessionFuture
[01:29:08.506] - received message: FutureResult
[01:29:08.506] - Received FutureResult
[01:29:08.507] - Erased future from FutureRegistry
[01:29:08.507] result() for ClusterFuture ...
[01:29:08.507] - result already collected: FutureResult
[01:29:08.507] result() for ClusterFuture ... done
[01:29:08.507] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:08.508] resolve() on list ...
[01:29:08.508]  recursive: 0
[01:29:08.508]  length: 2
[01:29:08.508]  elements: 'a', 'b'
[01:29:08.508]  length: 1 (resolved future 1)
[01:29:08.508]  length: 0 (resolved future 2)
[01:29:08.509] resolve() on list ... DONE
[01:29:08.509] A MultisessionFuture was resolved (and resolved itself)
[01:29:08.509] getGlobalsAndPackages() ...
[01:29:08.509] Searching for globals...
[01:29:08.511] - globals found: [3] '{', 'Sys.sleep', 'list'
[01:29:08.511] Searching for globals ... DONE
[01:29:08.511] Resolving globals: FALSE
[01:29:08.512] 
[01:29:08.512] 
[01:29:08.512] getGlobalsAndPackages() ... DONE
[01:29:08.512] run() for 'Future' ...
[01:29:08.512] - state: 'created'
[01:29:08.513] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:08.528] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:08.528] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:08.528]   - Field: 'node'
[01:29:08.529]   - Field: 'label'
[01:29:08.529]   - Field: 'local'
[01:29:08.529]   - Field: 'owner'
[01:29:08.529]   - Field: 'envir'
[01:29:08.529]   - Field: 'workers'
[01:29:08.530]   - Field: 'packages'
[01:29:08.530]   - Field: 'gc'
[01:29:08.530]   - Field: 'conditions'
[01:29:08.530]   - Field: 'persistent'
[01:29:08.530]   - Field: 'expr'
[01:29:08.530]   - Field: 'uuid'
[01:29:08.531]   - Field: 'seed'
[01:29:08.531]   - Field: 'version'
[01:29:08.531]   - Field: 'result'
[01:29:08.531]   - Field: 'asynchronous'
[01:29:08.531]   - Field: 'calls'
[01:29:08.532]   - Field: 'globals'
[01:29:08.532]   - Field: 'stdout'
[01:29:08.532]   - Field: 'earlySignal'
[01:29:08.532]   - Field: 'lazy'
[01:29:08.532]   - Field: 'state'
[01:29:08.532] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:08.533] - Launch lazy future ...
[01:29:08.533] Packages needed by the future expression (n = 0): <none>
[01:29:08.533] Packages needed by future strategies (n = 0): <none>
[01:29:08.534] {
[01:29:08.534]     {
[01:29:08.534]         {
[01:29:08.534]             ...future.startTime <- base::Sys.time()
[01:29:08.534]             {
[01:29:08.534]                 {
[01:29:08.534]                   {
[01:29:08.534]                     {
[01:29:08.534]                       base::local({
[01:29:08.534]                         has_future <- base::requireNamespace("future", 
[01:29:08.534]                           quietly = TRUE)
[01:29:08.534]                         if (has_future) {
[01:29:08.534]                           ns <- base::getNamespace("future")
[01:29:08.534]                           version <- ns[[".package"]][["version"]]
[01:29:08.534]                           if (is.null(version)) 
[01:29:08.534]                             version <- utils::packageVersion("future")
[01:29:08.534]                         }
[01:29:08.534]                         else {
[01:29:08.534]                           version <- NULL
[01:29:08.534]                         }
[01:29:08.534]                         if (!has_future || version < "1.8.0") {
[01:29:08.534]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:08.534]                             "", base::R.version$version.string), 
[01:29:08.534]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:08.534]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:08.534]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:08.534]                               "release", "version")], collapse = " "), 
[01:29:08.534]                             hostname = base::Sys.info()[["nodename"]])
[01:29:08.534]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:08.534]                             info)
[01:29:08.534]                           info <- base::paste(info, collapse = "; ")
[01:29:08.534]                           if (!has_future) {
[01:29:08.534]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:08.534]                               info)
[01:29:08.534]                           }
[01:29:08.534]                           else {
[01:29:08.534]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:08.534]                               info, version)
[01:29:08.534]                           }
[01:29:08.534]                           base::stop(msg)
[01:29:08.534]                         }
[01:29:08.534]                       })
[01:29:08.534]                     }
[01:29:08.534]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:08.534]                     base::options(mc.cores = 1L)
[01:29:08.534]                   }
[01:29:08.534]                   options(future.plan = NULL)
[01:29:08.534]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:08.534]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:08.534]                 }
[01:29:08.534]                 ...future.workdir <- getwd()
[01:29:08.534]             }
[01:29:08.534]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:08.534]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:08.534]         }
[01:29:08.534]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:08.534]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:08.534]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:08.534]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:08.534]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:08.534]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:08.534]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:08.534]             base::names(...future.oldOptions))
[01:29:08.534]     }
[01:29:08.534]     if (FALSE) {
[01:29:08.534]     }
[01:29:08.534]     else {
[01:29:08.534]         if (TRUE) {
[01:29:08.534]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:08.534]                 open = "w")
[01:29:08.534]         }
[01:29:08.534]         else {
[01:29:08.534]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:08.534]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:08.534]         }
[01:29:08.534]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:08.534]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:08.534]             base::sink(type = "output", split = FALSE)
[01:29:08.534]             base::close(...future.stdout)
[01:29:08.534]         }, add = TRUE)
[01:29:08.534]     }
[01:29:08.534]     ...future.frame <- base::sys.nframe()
[01:29:08.534]     ...future.conditions <- base::list()
[01:29:08.534]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:08.534]     if (FALSE) {
[01:29:08.534]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:08.534]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:08.534]     }
[01:29:08.534]     ...future.result <- base::tryCatch({
[01:29:08.534]         base::withCallingHandlers({
[01:29:08.534]             ...future.value <- base::withVisible(base::local({
[01:29:08.534]                 ...future.makeSendCondition <- base::local({
[01:29:08.534]                   sendCondition <- NULL
[01:29:08.534]                   function(frame = 1L) {
[01:29:08.534]                     if (is.function(sendCondition)) 
[01:29:08.534]                       return(sendCondition)
[01:29:08.534]                     ns <- getNamespace("parallel")
[01:29:08.534]                     if (exists("sendData", mode = "function", 
[01:29:08.534]                       envir = ns)) {
[01:29:08.534]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:08.534]                         envir = ns)
[01:29:08.534]                       envir <- sys.frame(frame)
[01:29:08.534]                       master <- NULL
[01:29:08.534]                       while (!identical(envir, .GlobalEnv) && 
[01:29:08.534]                         !identical(envir, emptyenv())) {
[01:29:08.534]                         if (exists("master", mode = "list", envir = envir, 
[01:29:08.534]                           inherits = FALSE)) {
[01:29:08.534]                           master <- get("master", mode = "list", 
[01:29:08.534]                             envir = envir, inherits = FALSE)
[01:29:08.534]                           if (inherits(master, c("SOCKnode", 
[01:29:08.534]                             "SOCK0node"))) {
[01:29:08.534]                             sendCondition <<- function(cond) {
[01:29:08.534]                               data <- list(type = "VALUE", value = cond, 
[01:29:08.534]                                 success = TRUE)
[01:29:08.534]                               parallel_sendData(master, data)
[01:29:08.534]                             }
[01:29:08.534]                             return(sendCondition)
[01:29:08.534]                           }
[01:29:08.534]                         }
[01:29:08.534]                         frame <- frame + 1L
[01:29:08.534]                         envir <- sys.frame(frame)
[01:29:08.534]                       }
[01:29:08.534]                     }
[01:29:08.534]                     sendCondition <<- function(cond) NULL
[01:29:08.534]                   }
[01:29:08.534]                 })
[01:29:08.534]                 withCallingHandlers({
[01:29:08.534]                   {
[01:29:08.534]                     Sys.sleep(0.5)
[01:29:08.534]                     list(a = 1, b = 42L)
[01:29:08.534]                   }
[01:29:08.534]                 }, immediateCondition = function(cond) {
[01:29:08.534]                   sendCondition <- ...future.makeSendCondition()
[01:29:08.534]                   sendCondition(cond)
[01:29:08.534]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:08.534]                   {
[01:29:08.534]                     inherits <- base::inherits
[01:29:08.534]                     invokeRestart <- base::invokeRestart
[01:29:08.534]                     is.null <- base::is.null
[01:29:08.534]                     muffled <- FALSE
[01:29:08.534]                     if (inherits(cond, "message")) {
[01:29:08.534]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:08.534]                       if (muffled) 
[01:29:08.534]                         invokeRestart("muffleMessage")
[01:29:08.534]                     }
[01:29:08.534]                     else if (inherits(cond, "warning")) {
[01:29:08.534]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:08.534]                       if (muffled) 
[01:29:08.534]                         invokeRestart("muffleWarning")
[01:29:08.534]                     }
[01:29:08.534]                     else if (inherits(cond, "condition")) {
[01:29:08.534]                       if (!is.null(pattern)) {
[01:29:08.534]                         computeRestarts <- base::computeRestarts
[01:29:08.534]                         grepl <- base::grepl
[01:29:08.534]                         restarts <- computeRestarts(cond)
[01:29:08.534]                         for (restart in restarts) {
[01:29:08.534]                           name <- restart$name
[01:29:08.534]                           if (is.null(name)) 
[01:29:08.534]                             next
[01:29:08.534]                           if (!grepl(pattern, name)) 
[01:29:08.534]                             next
[01:29:08.534]                           invokeRestart(restart)
[01:29:08.534]                           muffled <- TRUE
[01:29:08.534]                           break
[01:29:08.534]                         }
[01:29:08.534]                       }
[01:29:08.534]                     }
[01:29:08.534]                     invisible(muffled)
[01:29:08.534]                   }
[01:29:08.534]                   muffleCondition(cond)
[01:29:08.534]                 })
[01:29:08.534]             }))
[01:29:08.534]             future::FutureResult(value = ...future.value$value, 
[01:29:08.534]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:08.534]                   ...future.rng), globalenv = if (FALSE) 
[01:29:08.534]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:08.534]                     ...future.globalenv.names))
[01:29:08.534]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:08.534]         }, condition = base::local({
[01:29:08.534]             c <- base::c
[01:29:08.534]             inherits <- base::inherits
[01:29:08.534]             invokeRestart <- base::invokeRestart
[01:29:08.534]             length <- base::length
[01:29:08.534]             list <- base::list
[01:29:08.534]             seq.int <- base::seq.int
[01:29:08.534]             signalCondition <- base::signalCondition
[01:29:08.534]             sys.calls <- base::sys.calls
[01:29:08.534]             `[[` <- base::`[[`
[01:29:08.534]             `+` <- base::`+`
[01:29:08.534]             `<<-` <- base::`<<-`
[01:29:08.534]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:08.534]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:08.534]                   3L)]
[01:29:08.534]             }
[01:29:08.534]             function(cond) {
[01:29:08.534]                 is_error <- inherits(cond, "error")
[01:29:08.534]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:08.534]                   NULL)
[01:29:08.534]                 if (is_error) {
[01:29:08.534]                   sessionInformation <- function() {
[01:29:08.534]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:08.534]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:08.534]                       search = base::search(), system = base::Sys.info())
[01:29:08.534]                   }
[01:29:08.534]                   ...future.conditions[[length(...future.conditions) + 
[01:29:08.534]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:08.534]                     cond$call), session = sessionInformation(), 
[01:29:08.534]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:08.534]                   signalCondition(cond)
[01:29:08.534]                 }
[01:29:08.534]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:08.534]                 "immediateCondition"))) {
[01:29:08.534]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:08.534]                   ...future.conditions[[length(...future.conditions) + 
[01:29:08.534]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:08.534]                   if (TRUE && !signal) {
[01:29:08.534]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:08.534]                     {
[01:29:08.534]                       inherits <- base::inherits
[01:29:08.534]                       invokeRestart <- base::invokeRestart
[01:29:08.534]                       is.null <- base::is.null
[01:29:08.534]                       muffled <- FALSE
[01:29:08.534]                       if (inherits(cond, "message")) {
[01:29:08.534]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:08.534]                         if (muffled) 
[01:29:08.534]                           invokeRestart("muffleMessage")
[01:29:08.534]                       }
[01:29:08.534]                       else if (inherits(cond, "warning")) {
[01:29:08.534]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:08.534]                         if (muffled) 
[01:29:08.534]                           invokeRestart("muffleWarning")
[01:29:08.534]                       }
[01:29:08.534]                       else if (inherits(cond, "condition")) {
[01:29:08.534]                         if (!is.null(pattern)) {
[01:29:08.534]                           computeRestarts <- base::computeRestarts
[01:29:08.534]                           grepl <- base::grepl
[01:29:08.534]                           restarts <- computeRestarts(cond)
[01:29:08.534]                           for (restart in restarts) {
[01:29:08.534]                             name <- restart$name
[01:29:08.534]                             if (is.null(name)) 
[01:29:08.534]                               next
[01:29:08.534]                             if (!grepl(pattern, name)) 
[01:29:08.534]                               next
[01:29:08.534]                             invokeRestart(restart)
[01:29:08.534]                             muffled <- TRUE
[01:29:08.534]                             break
[01:29:08.534]                           }
[01:29:08.534]                         }
[01:29:08.534]                       }
[01:29:08.534]                       invisible(muffled)
[01:29:08.534]                     }
[01:29:08.534]                     muffleCondition(cond, pattern = "^muffle")
[01:29:08.534]                   }
[01:29:08.534]                 }
[01:29:08.534]                 else {
[01:29:08.534]                   if (TRUE) {
[01:29:08.534]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:08.534]                     {
[01:29:08.534]                       inherits <- base::inherits
[01:29:08.534]                       invokeRestart <- base::invokeRestart
[01:29:08.534]                       is.null <- base::is.null
[01:29:08.534]                       muffled <- FALSE
[01:29:08.534]                       if (inherits(cond, "message")) {
[01:29:08.534]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:08.534]                         if (muffled) 
[01:29:08.534]                           invokeRestart("muffleMessage")
[01:29:08.534]                       }
[01:29:08.534]                       else if (inherits(cond, "warning")) {
[01:29:08.534]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:08.534]                         if (muffled) 
[01:29:08.534]                           invokeRestart("muffleWarning")
[01:29:08.534]                       }
[01:29:08.534]                       else if (inherits(cond, "condition")) {
[01:29:08.534]                         if (!is.null(pattern)) {
[01:29:08.534]                           computeRestarts <- base::computeRestarts
[01:29:08.534]                           grepl <- base::grepl
[01:29:08.534]                           restarts <- computeRestarts(cond)
[01:29:08.534]                           for (restart in restarts) {
[01:29:08.534]                             name <- restart$name
[01:29:08.534]                             if (is.null(name)) 
[01:29:08.534]                               next
[01:29:08.534]                             if (!grepl(pattern, name)) 
[01:29:08.534]                               next
[01:29:08.534]                             invokeRestart(restart)
[01:29:08.534]                             muffled <- TRUE
[01:29:08.534]                             break
[01:29:08.534]                           }
[01:29:08.534]                         }
[01:29:08.534]                       }
[01:29:08.534]                       invisible(muffled)
[01:29:08.534]                     }
[01:29:08.534]                     muffleCondition(cond, pattern = "^muffle")
[01:29:08.534]                   }
[01:29:08.534]                 }
[01:29:08.534]             }
[01:29:08.534]         }))
[01:29:08.534]     }, error = function(ex) {
[01:29:08.534]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:08.534]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:08.534]                 ...future.rng), started = ...future.startTime, 
[01:29:08.534]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:08.534]             version = "1.8"), class = "FutureResult")
[01:29:08.534]     }, finally = {
[01:29:08.534]         if (!identical(...future.workdir, getwd())) 
[01:29:08.534]             setwd(...future.workdir)
[01:29:08.534]         {
[01:29:08.534]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:08.534]                 ...future.oldOptions$nwarnings <- NULL
[01:29:08.534]             }
[01:29:08.534]             base::options(...future.oldOptions)
[01:29:08.534]             if (.Platform$OS.type == "windows") {
[01:29:08.534]                 old_names <- names(...future.oldEnvVars)
[01:29:08.534]                 envs <- base::Sys.getenv()
[01:29:08.534]                 names <- names(envs)
[01:29:08.534]                 common <- intersect(names, old_names)
[01:29:08.534]                 added <- setdiff(names, old_names)
[01:29:08.534]                 removed <- setdiff(old_names, names)
[01:29:08.534]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:08.534]                   envs[common]]
[01:29:08.534]                 NAMES <- toupper(changed)
[01:29:08.534]                 args <- list()
[01:29:08.534]                 for (kk in seq_along(NAMES)) {
[01:29:08.534]                   name <- changed[[kk]]
[01:29:08.534]                   NAME <- NAMES[[kk]]
[01:29:08.534]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:08.534]                     next
[01:29:08.534]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:08.534]                 }
[01:29:08.534]                 NAMES <- toupper(added)
[01:29:08.534]                 for (kk in seq_along(NAMES)) {
[01:29:08.534]                   name <- added[[kk]]
[01:29:08.534]                   NAME <- NAMES[[kk]]
[01:29:08.534]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:08.534]                     next
[01:29:08.534]                   args[[name]] <- ""
[01:29:08.534]                 }
[01:29:08.534]                 NAMES <- toupper(removed)
[01:29:08.534]                 for (kk in seq_along(NAMES)) {
[01:29:08.534]                   name <- removed[[kk]]
[01:29:08.534]                   NAME <- NAMES[[kk]]
[01:29:08.534]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:08.534]                     next
[01:29:08.534]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:08.534]                 }
[01:29:08.534]                 if (length(args) > 0) 
[01:29:08.534]                   base::do.call(base::Sys.setenv, args = args)
[01:29:08.534]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:08.534]             }
[01:29:08.534]             else {
[01:29:08.534]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:08.534]             }
[01:29:08.534]             {
[01:29:08.534]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:08.534]                   0L) {
[01:29:08.534]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:08.534]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:08.534]                   base::options(opts)
[01:29:08.534]                 }
[01:29:08.534]                 {
[01:29:08.534]                   {
[01:29:08.534]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:08.534]                     NULL
[01:29:08.534]                   }
[01:29:08.534]                   options(future.plan = NULL)
[01:29:08.534]                   if (is.na(NA_character_)) 
[01:29:08.534]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:08.534]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:08.534]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:08.534]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:08.534]                     envir = parent.frame()) 
[01:29:08.534]                   {
[01:29:08.534]                     if (is.function(workers)) 
[01:29:08.534]                       workers <- workers()
[01:29:08.534]                     workers <- structure(as.integer(workers), 
[01:29:08.534]                       class = class(workers))
[01:29:08.534]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:08.534]                       workers >= 1)
[01:29:08.534]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:08.534]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:08.534]                     }
[01:29:08.534]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:08.534]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:08.534]                       envir = envir)
[01:29:08.534]                     if (!future$lazy) 
[01:29:08.534]                       future <- run(future)
[01:29:08.534]                     invisible(future)
[01:29:08.534]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:08.534]                 }
[01:29:08.534]             }
[01:29:08.534]         }
[01:29:08.534]     })
[01:29:08.534]     if (TRUE) {
[01:29:08.534]         base::sink(type = "output", split = FALSE)
[01:29:08.534]         if (TRUE) {
[01:29:08.534]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:08.534]         }
[01:29:08.534]         else {
[01:29:08.534]             ...future.result["stdout"] <- base::list(NULL)
[01:29:08.534]         }
[01:29:08.534]         base::close(...future.stdout)
[01:29:08.534]         ...future.stdout <- NULL
[01:29:08.534]     }
[01:29:08.534]     ...future.result$conditions <- ...future.conditions
[01:29:08.534]     ...future.result$finished <- base::Sys.time()
[01:29:08.534]     ...future.result
[01:29:08.534] }
[01:29:08.540] MultisessionFuture started
[01:29:08.540] - Launch lazy future ... done
[01:29:08.540] run() for 'MultisessionFuture' ... done
[01:29:09.067] receiveMessageFromWorker() for ClusterFuture ...
[01:29:09.068] - Validating connection of MultisessionFuture
[01:29:09.068] - received message: FutureResult
[01:29:09.068] - Received FutureResult
[01:29:09.069] - Erased future from FutureRegistry
[01:29:09.069] result() for ClusterFuture ...
[01:29:09.069] - result already collected: FutureResult
[01:29:09.069] result() for ClusterFuture ... done
[01:29:09.069] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:09.070] resolve() on list ...
[01:29:09.070]  recursive: 0
[01:29:09.070]  length: 2
[01:29:09.070]  elements: 'a', 'b'
[01:29:09.070]  length: 1 (resolved future 1)
[01:29:09.070]  length: 0 (resolved future 2)
[01:29:09.071] resolve() on list ... DONE
[01:29:09.071] A MultisessionFuture was resolved (and resolved itself)
- w/ exception ...
[01:29:09.071] getGlobalsAndPackages() ...
[01:29:09.071] Searching for globals...
[01:29:09.072] - globals found: [2] 'list', 'stop'
[01:29:09.072] Searching for globals ... DONE
[01:29:09.073] Resolving globals: FALSE
[01:29:09.073] 
[01:29:09.073] 
[01:29:09.073] getGlobalsAndPackages() ... DONE
[01:29:09.074] run() for 'Future' ...
[01:29:09.074] - state: 'created'
[01:29:09.074] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:09.089] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:09.089] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:09.090]   - Field: 'node'
[01:29:09.090]   - Field: 'label'
[01:29:09.090]   - Field: 'local'
[01:29:09.090]   - Field: 'owner'
[01:29:09.090]   - Field: 'envir'
[01:29:09.091]   - Field: 'workers'
[01:29:09.091]   - Field: 'packages'
[01:29:09.091]   - Field: 'gc'
[01:29:09.091]   - Field: 'conditions'
[01:29:09.091]   - Field: 'persistent'
[01:29:09.091]   - Field: 'expr'
[01:29:09.092]   - Field: 'uuid'
[01:29:09.092]   - Field: 'seed'
[01:29:09.092]   - Field: 'version'
[01:29:09.092]   - Field: 'result'
[01:29:09.092]   - Field: 'asynchronous'
[01:29:09.093]   - Field: 'calls'
[01:29:09.093]   - Field: 'globals'
[01:29:09.093]   - Field: 'stdout'
[01:29:09.093]   - Field: 'earlySignal'
[01:29:09.093]   - Field: 'lazy'
[01:29:09.093]   - Field: 'state'
[01:29:09.094] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:09.094] - Launch lazy future ...
[01:29:09.094] Packages needed by the future expression (n = 0): <none>
[01:29:09.094] Packages needed by future strategies (n = 0): <none>
[01:29:09.095] {
[01:29:09.095]     {
[01:29:09.095]         {
[01:29:09.095]             ...future.startTime <- base::Sys.time()
[01:29:09.095]             {
[01:29:09.095]                 {
[01:29:09.095]                   {
[01:29:09.095]                     {
[01:29:09.095]                       base::local({
[01:29:09.095]                         has_future <- base::requireNamespace("future", 
[01:29:09.095]                           quietly = TRUE)
[01:29:09.095]                         if (has_future) {
[01:29:09.095]                           ns <- base::getNamespace("future")
[01:29:09.095]                           version <- ns[[".package"]][["version"]]
[01:29:09.095]                           if (is.null(version)) 
[01:29:09.095]                             version <- utils::packageVersion("future")
[01:29:09.095]                         }
[01:29:09.095]                         else {
[01:29:09.095]                           version <- NULL
[01:29:09.095]                         }
[01:29:09.095]                         if (!has_future || version < "1.8.0") {
[01:29:09.095]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:09.095]                             "", base::R.version$version.string), 
[01:29:09.095]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:09.095]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:09.095]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:09.095]                               "release", "version")], collapse = " "), 
[01:29:09.095]                             hostname = base::Sys.info()[["nodename"]])
[01:29:09.095]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:09.095]                             info)
[01:29:09.095]                           info <- base::paste(info, collapse = "; ")
[01:29:09.095]                           if (!has_future) {
[01:29:09.095]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:09.095]                               info)
[01:29:09.095]                           }
[01:29:09.095]                           else {
[01:29:09.095]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:09.095]                               info, version)
[01:29:09.095]                           }
[01:29:09.095]                           base::stop(msg)
[01:29:09.095]                         }
[01:29:09.095]                       })
[01:29:09.095]                     }
[01:29:09.095]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:09.095]                     base::options(mc.cores = 1L)
[01:29:09.095]                   }
[01:29:09.095]                   options(future.plan = NULL)
[01:29:09.095]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:09.095]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:09.095]                 }
[01:29:09.095]                 ...future.workdir <- getwd()
[01:29:09.095]             }
[01:29:09.095]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:09.095]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:09.095]         }
[01:29:09.095]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:09.095]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:09.095]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:09.095]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:09.095]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:09.095]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:09.095]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:09.095]             base::names(...future.oldOptions))
[01:29:09.095]     }
[01:29:09.095]     if (FALSE) {
[01:29:09.095]     }
[01:29:09.095]     else {
[01:29:09.095]         if (TRUE) {
[01:29:09.095]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:09.095]                 open = "w")
[01:29:09.095]         }
[01:29:09.095]         else {
[01:29:09.095]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:09.095]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:09.095]         }
[01:29:09.095]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:09.095]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:09.095]             base::sink(type = "output", split = FALSE)
[01:29:09.095]             base::close(...future.stdout)
[01:29:09.095]         }, add = TRUE)
[01:29:09.095]     }
[01:29:09.095]     ...future.frame <- base::sys.nframe()
[01:29:09.095]     ...future.conditions <- base::list()
[01:29:09.095]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:09.095]     if (FALSE) {
[01:29:09.095]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:09.095]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:09.095]     }
[01:29:09.095]     ...future.result <- base::tryCatch({
[01:29:09.095]         base::withCallingHandlers({
[01:29:09.095]             ...future.value <- base::withVisible(base::local({
[01:29:09.095]                 ...future.makeSendCondition <- base::local({
[01:29:09.095]                   sendCondition <- NULL
[01:29:09.095]                   function(frame = 1L) {
[01:29:09.095]                     if (is.function(sendCondition)) 
[01:29:09.095]                       return(sendCondition)
[01:29:09.095]                     ns <- getNamespace("parallel")
[01:29:09.095]                     if (exists("sendData", mode = "function", 
[01:29:09.095]                       envir = ns)) {
[01:29:09.095]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:09.095]                         envir = ns)
[01:29:09.095]                       envir <- sys.frame(frame)
[01:29:09.095]                       master <- NULL
[01:29:09.095]                       while (!identical(envir, .GlobalEnv) && 
[01:29:09.095]                         !identical(envir, emptyenv())) {
[01:29:09.095]                         if (exists("master", mode = "list", envir = envir, 
[01:29:09.095]                           inherits = FALSE)) {
[01:29:09.095]                           master <- get("master", mode = "list", 
[01:29:09.095]                             envir = envir, inherits = FALSE)
[01:29:09.095]                           if (inherits(master, c("SOCKnode", 
[01:29:09.095]                             "SOCK0node"))) {
[01:29:09.095]                             sendCondition <<- function(cond) {
[01:29:09.095]                               data <- list(type = "VALUE", value = cond, 
[01:29:09.095]                                 success = TRUE)
[01:29:09.095]                               parallel_sendData(master, data)
[01:29:09.095]                             }
[01:29:09.095]                             return(sendCondition)
[01:29:09.095]                           }
[01:29:09.095]                         }
[01:29:09.095]                         frame <- frame + 1L
[01:29:09.095]                         envir <- sys.frame(frame)
[01:29:09.095]                       }
[01:29:09.095]                     }
[01:29:09.095]                     sendCondition <<- function(cond) NULL
[01:29:09.095]                   }
[01:29:09.095]                 })
[01:29:09.095]                 withCallingHandlers({
[01:29:09.095]                   list(a = 1, b = 42L, c = stop("Nah!"))
[01:29:09.095]                 }, immediateCondition = function(cond) {
[01:29:09.095]                   sendCondition <- ...future.makeSendCondition()
[01:29:09.095]                   sendCondition(cond)
[01:29:09.095]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:09.095]                   {
[01:29:09.095]                     inherits <- base::inherits
[01:29:09.095]                     invokeRestart <- base::invokeRestart
[01:29:09.095]                     is.null <- base::is.null
[01:29:09.095]                     muffled <- FALSE
[01:29:09.095]                     if (inherits(cond, "message")) {
[01:29:09.095]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:09.095]                       if (muffled) 
[01:29:09.095]                         invokeRestart("muffleMessage")
[01:29:09.095]                     }
[01:29:09.095]                     else if (inherits(cond, "warning")) {
[01:29:09.095]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:09.095]                       if (muffled) 
[01:29:09.095]                         invokeRestart("muffleWarning")
[01:29:09.095]                     }
[01:29:09.095]                     else if (inherits(cond, "condition")) {
[01:29:09.095]                       if (!is.null(pattern)) {
[01:29:09.095]                         computeRestarts <- base::computeRestarts
[01:29:09.095]                         grepl <- base::grepl
[01:29:09.095]                         restarts <- computeRestarts(cond)
[01:29:09.095]                         for (restart in restarts) {
[01:29:09.095]                           name <- restart$name
[01:29:09.095]                           if (is.null(name)) 
[01:29:09.095]                             next
[01:29:09.095]                           if (!grepl(pattern, name)) 
[01:29:09.095]                             next
[01:29:09.095]                           invokeRestart(restart)
[01:29:09.095]                           muffled <- TRUE
[01:29:09.095]                           break
[01:29:09.095]                         }
[01:29:09.095]                       }
[01:29:09.095]                     }
[01:29:09.095]                     invisible(muffled)
[01:29:09.095]                   }
[01:29:09.095]                   muffleCondition(cond)
[01:29:09.095]                 })
[01:29:09.095]             }))
[01:29:09.095]             future::FutureResult(value = ...future.value$value, 
[01:29:09.095]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:09.095]                   ...future.rng), globalenv = if (FALSE) 
[01:29:09.095]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:09.095]                     ...future.globalenv.names))
[01:29:09.095]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:09.095]         }, condition = base::local({
[01:29:09.095]             c <- base::c
[01:29:09.095]             inherits <- base::inherits
[01:29:09.095]             invokeRestart <- base::invokeRestart
[01:29:09.095]             length <- base::length
[01:29:09.095]             list <- base::list
[01:29:09.095]             seq.int <- base::seq.int
[01:29:09.095]             signalCondition <- base::signalCondition
[01:29:09.095]             sys.calls <- base::sys.calls
[01:29:09.095]             `[[` <- base::`[[`
[01:29:09.095]             `+` <- base::`+`
[01:29:09.095]             `<<-` <- base::`<<-`
[01:29:09.095]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:09.095]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:09.095]                   3L)]
[01:29:09.095]             }
[01:29:09.095]             function(cond) {
[01:29:09.095]                 is_error <- inherits(cond, "error")
[01:29:09.095]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:09.095]                   NULL)
[01:29:09.095]                 if (is_error) {
[01:29:09.095]                   sessionInformation <- function() {
[01:29:09.095]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:09.095]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:09.095]                       search = base::search(), system = base::Sys.info())
[01:29:09.095]                   }
[01:29:09.095]                   ...future.conditions[[length(...future.conditions) + 
[01:29:09.095]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:09.095]                     cond$call), session = sessionInformation(), 
[01:29:09.095]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:09.095]                   signalCondition(cond)
[01:29:09.095]                 }
[01:29:09.095]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:09.095]                 "immediateCondition"))) {
[01:29:09.095]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:09.095]                   ...future.conditions[[length(...future.conditions) + 
[01:29:09.095]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:09.095]                   if (TRUE && !signal) {
[01:29:09.095]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:09.095]                     {
[01:29:09.095]                       inherits <- base::inherits
[01:29:09.095]                       invokeRestart <- base::invokeRestart
[01:29:09.095]                       is.null <- base::is.null
[01:29:09.095]                       muffled <- FALSE
[01:29:09.095]                       if (inherits(cond, "message")) {
[01:29:09.095]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:09.095]                         if (muffled) 
[01:29:09.095]                           invokeRestart("muffleMessage")
[01:29:09.095]                       }
[01:29:09.095]                       else if (inherits(cond, "warning")) {
[01:29:09.095]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:09.095]                         if (muffled) 
[01:29:09.095]                           invokeRestart("muffleWarning")
[01:29:09.095]                       }
[01:29:09.095]                       else if (inherits(cond, "condition")) {
[01:29:09.095]                         if (!is.null(pattern)) {
[01:29:09.095]                           computeRestarts <- base::computeRestarts
[01:29:09.095]                           grepl <- base::grepl
[01:29:09.095]                           restarts <- computeRestarts(cond)
[01:29:09.095]                           for (restart in restarts) {
[01:29:09.095]                             name <- restart$name
[01:29:09.095]                             if (is.null(name)) 
[01:29:09.095]                               next
[01:29:09.095]                             if (!grepl(pattern, name)) 
[01:29:09.095]                               next
[01:29:09.095]                             invokeRestart(restart)
[01:29:09.095]                             muffled <- TRUE
[01:29:09.095]                             break
[01:29:09.095]                           }
[01:29:09.095]                         }
[01:29:09.095]                       }
[01:29:09.095]                       invisible(muffled)
[01:29:09.095]                     }
[01:29:09.095]                     muffleCondition(cond, pattern = "^muffle")
[01:29:09.095]                   }
[01:29:09.095]                 }
[01:29:09.095]                 else {
[01:29:09.095]                   if (TRUE) {
[01:29:09.095]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:09.095]                     {
[01:29:09.095]                       inherits <- base::inherits
[01:29:09.095]                       invokeRestart <- base::invokeRestart
[01:29:09.095]                       is.null <- base::is.null
[01:29:09.095]                       muffled <- FALSE
[01:29:09.095]                       if (inherits(cond, "message")) {
[01:29:09.095]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:09.095]                         if (muffled) 
[01:29:09.095]                           invokeRestart("muffleMessage")
[01:29:09.095]                       }
[01:29:09.095]                       else if (inherits(cond, "warning")) {
[01:29:09.095]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:09.095]                         if (muffled) 
[01:29:09.095]                           invokeRestart("muffleWarning")
[01:29:09.095]                       }
[01:29:09.095]                       else if (inherits(cond, "condition")) {
[01:29:09.095]                         if (!is.null(pattern)) {
[01:29:09.095]                           computeRestarts <- base::computeRestarts
[01:29:09.095]                           grepl <- base::grepl
[01:29:09.095]                           restarts <- computeRestarts(cond)
[01:29:09.095]                           for (restart in restarts) {
[01:29:09.095]                             name <- restart$name
[01:29:09.095]                             if (is.null(name)) 
[01:29:09.095]                               next
[01:29:09.095]                             if (!grepl(pattern, name)) 
[01:29:09.095]                               next
[01:29:09.095]                             invokeRestart(restart)
[01:29:09.095]                             muffled <- TRUE
[01:29:09.095]                             break
[01:29:09.095]                           }
[01:29:09.095]                         }
[01:29:09.095]                       }
[01:29:09.095]                       invisible(muffled)
[01:29:09.095]                     }
[01:29:09.095]                     muffleCondition(cond, pattern = "^muffle")
[01:29:09.095]                   }
[01:29:09.095]                 }
[01:29:09.095]             }
[01:29:09.095]         }))
[01:29:09.095]     }, error = function(ex) {
[01:29:09.095]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:09.095]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:09.095]                 ...future.rng), started = ...future.startTime, 
[01:29:09.095]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:09.095]             version = "1.8"), class = "FutureResult")
[01:29:09.095]     }, finally = {
[01:29:09.095]         if (!identical(...future.workdir, getwd())) 
[01:29:09.095]             setwd(...future.workdir)
[01:29:09.095]         {
[01:29:09.095]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:09.095]                 ...future.oldOptions$nwarnings <- NULL
[01:29:09.095]             }
[01:29:09.095]             base::options(...future.oldOptions)
[01:29:09.095]             if (.Platform$OS.type == "windows") {
[01:29:09.095]                 old_names <- names(...future.oldEnvVars)
[01:29:09.095]                 envs <- base::Sys.getenv()
[01:29:09.095]                 names <- names(envs)
[01:29:09.095]                 common <- intersect(names, old_names)
[01:29:09.095]                 added <- setdiff(names, old_names)
[01:29:09.095]                 removed <- setdiff(old_names, names)
[01:29:09.095]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:09.095]                   envs[common]]
[01:29:09.095]                 NAMES <- toupper(changed)
[01:29:09.095]                 args <- list()
[01:29:09.095]                 for (kk in seq_along(NAMES)) {
[01:29:09.095]                   name <- changed[[kk]]
[01:29:09.095]                   NAME <- NAMES[[kk]]
[01:29:09.095]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:09.095]                     next
[01:29:09.095]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:09.095]                 }
[01:29:09.095]                 NAMES <- toupper(added)
[01:29:09.095]                 for (kk in seq_along(NAMES)) {
[01:29:09.095]                   name <- added[[kk]]
[01:29:09.095]                   NAME <- NAMES[[kk]]
[01:29:09.095]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:09.095]                     next
[01:29:09.095]                   args[[name]] <- ""
[01:29:09.095]                 }
[01:29:09.095]                 NAMES <- toupper(removed)
[01:29:09.095]                 for (kk in seq_along(NAMES)) {
[01:29:09.095]                   name <- removed[[kk]]
[01:29:09.095]                   NAME <- NAMES[[kk]]
[01:29:09.095]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:09.095]                     next
[01:29:09.095]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:09.095]                 }
[01:29:09.095]                 if (length(args) > 0) 
[01:29:09.095]                   base::do.call(base::Sys.setenv, args = args)
[01:29:09.095]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:09.095]             }
[01:29:09.095]             else {
[01:29:09.095]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:09.095]             }
[01:29:09.095]             {
[01:29:09.095]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:09.095]                   0L) {
[01:29:09.095]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:09.095]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:09.095]                   base::options(opts)
[01:29:09.095]                 }
[01:29:09.095]                 {
[01:29:09.095]                   {
[01:29:09.095]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:09.095]                     NULL
[01:29:09.095]                   }
[01:29:09.095]                   options(future.plan = NULL)
[01:29:09.095]                   if (is.na(NA_character_)) 
[01:29:09.095]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:09.095]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:09.095]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:09.095]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:09.095]                     envir = parent.frame()) 
[01:29:09.095]                   {
[01:29:09.095]                     if (is.function(workers)) 
[01:29:09.095]                       workers <- workers()
[01:29:09.095]                     workers <- structure(as.integer(workers), 
[01:29:09.095]                       class = class(workers))
[01:29:09.095]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:09.095]                       workers >= 1)
[01:29:09.095]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:09.095]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:09.095]                     }
[01:29:09.095]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:09.095]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:09.095]                       envir = envir)
[01:29:09.095]                     if (!future$lazy) 
[01:29:09.095]                       future <- run(future)
[01:29:09.095]                     invisible(future)
[01:29:09.095]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:09.095]                 }
[01:29:09.095]             }
[01:29:09.095]         }
[01:29:09.095]     })
[01:29:09.095]     if (TRUE) {
[01:29:09.095]         base::sink(type = "output", split = FALSE)
[01:29:09.095]         if (TRUE) {
[01:29:09.095]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:09.095]         }
[01:29:09.095]         else {
[01:29:09.095]             ...future.result["stdout"] <- base::list(NULL)
[01:29:09.095]         }
[01:29:09.095]         base::close(...future.stdout)
[01:29:09.095]         ...future.stdout <- NULL
[01:29:09.095]     }
[01:29:09.095]     ...future.result$conditions <- ...future.conditions
[01:29:09.095]     ...future.result$finished <- base::Sys.time()
[01:29:09.095]     ...future.result
[01:29:09.095] }
[01:29:09.101] MultisessionFuture started
[01:29:09.101] - Launch lazy future ... done
[01:29:09.101] run() for 'MultisessionFuture' ... done
[01:29:09.119] receiveMessageFromWorker() for ClusterFuture ...
[01:29:09.119] - Validating connection of MultisessionFuture
[01:29:09.119] - received message: FutureResult
[01:29:09.120] - Received FutureResult
[01:29:09.120] - Erased future from FutureRegistry
[01:29:09.120] result() for ClusterFuture ...
[01:29:09.120] - result already collected: FutureResult
[01:29:09.120] result() for ClusterFuture ... done
[01:29:09.120] signalConditions() ...
[01:29:09.121]  - include = 'immediateCondition'
[01:29:09.121]  - exclude = 
[01:29:09.121]  - resignal = FALSE
[01:29:09.121]  - Number of conditions: 1
[01:29:09.121] signalConditions() ... done
[01:29:09.121] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:09.122] A MultisessionFuture was resolved (and resolved itself)
[01:29:09.122] getGlobalsAndPackages() ...
[01:29:09.122] Searching for globals...
[01:29:09.123] - globals found: [2] 'list', 'stop'
[01:29:09.123] Searching for globals ... DONE
[01:29:09.123] Resolving globals: FALSE
[01:29:09.124] 
[01:29:09.124] 
[01:29:09.124] getGlobalsAndPackages() ... DONE
[01:29:09.124] run() for 'Future' ...
[01:29:09.124] - state: 'created'
[01:29:09.125] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:09.139] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:09.139] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:09.140]   - Field: 'node'
[01:29:09.140]   - Field: 'label'
[01:29:09.140]   - Field: 'local'
[01:29:09.140]   - Field: 'owner'
[01:29:09.140]   - Field: 'envir'
[01:29:09.141]   - Field: 'workers'
[01:29:09.142]   - Field: 'packages'
[01:29:09.142]   - Field: 'gc'
[01:29:09.142]   - Field: 'conditions'
[01:29:09.142]   - Field: 'persistent'
[01:29:09.142]   - Field: 'expr'
[01:29:09.143]   - Field: 'uuid'
[01:29:09.143]   - Field: 'seed'
[01:29:09.143]   - Field: 'version'
[01:29:09.143]   - Field: 'result'
[01:29:09.144]   - Field: 'asynchronous'
[01:29:09.144]   - Field: 'calls'
[01:29:09.144]   - Field: 'globals'
[01:29:09.144]   - Field: 'stdout'
[01:29:09.144]   - Field: 'earlySignal'
[01:29:09.145]   - Field: 'lazy'
[01:29:09.145]   - Field: 'state'
[01:29:09.145] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:09.145] - Launch lazy future ...
[01:29:09.146] Packages needed by the future expression (n = 0): <none>
[01:29:09.147] Packages needed by future strategies (n = 0): <none>
[01:29:09.148] {
[01:29:09.148]     {
[01:29:09.148]         {
[01:29:09.148]             ...future.startTime <- base::Sys.time()
[01:29:09.148]             {
[01:29:09.148]                 {
[01:29:09.148]                   {
[01:29:09.148]                     {
[01:29:09.148]                       base::local({
[01:29:09.148]                         has_future <- base::requireNamespace("future", 
[01:29:09.148]                           quietly = TRUE)
[01:29:09.148]                         if (has_future) {
[01:29:09.148]                           ns <- base::getNamespace("future")
[01:29:09.148]                           version <- ns[[".package"]][["version"]]
[01:29:09.148]                           if (is.null(version)) 
[01:29:09.148]                             version <- utils::packageVersion("future")
[01:29:09.148]                         }
[01:29:09.148]                         else {
[01:29:09.148]                           version <- NULL
[01:29:09.148]                         }
[01:29:09.148]                         if (!has_future || version < "1.8.0") {
[01:29:09.148]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:09.148]                             "", base::R.version$version.string), 
[01:29:09.148]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:09.148]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:09.148]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:09.148]                               "release", "version")], collapse = " "), 
[01:29:09.148]                             hostname = base::Sys.info()[["nodename"]])
[01:29:09.148]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:09.148]                             info)
[01:29:09.148]                           info <- base::paste(info, collapse = "; ")
[01:29:09.148]                           if (!has_future) {
[01:29:09.148]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:09.148]                               info)
[01:29:09.148]                           }
[01:29:09.148]                           else {
[01:29:09.148]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:09.148]                               info, version)
[01:29:09.148]                           }
[01:29:09.148]                           base::stop(msg)
[01:29:09.148]                         }
[01:29:09.148]                       })
[01:29:09.148]                     }
[01:29:09.148]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:09.148]                     base::options(mc.cores = 1L)
[01:29:09.148]                   }
[01:29:09.148]                   options(future.plan = NULL)
[01:29:09.148]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:09.148]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:09.148]                 }
[01:29:09.148]                 ...future.workdir <- getwd()
[01:29:09.148]             }
[01:29:09.148]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:09.148]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:09.148]         }
[01:29:09.148]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:09.148]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:09.148]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:09.148]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:09.148]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:09.148]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:09.148]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:09.148]             base::names(...future.oldOptions))
[01:29:09.148]     }
[01:29:09.148]     if (FALSE) {
[01:29:09.148]     }
[01:29:09.148]     else {
[01:29:09.148]         if (TRUE) {
[01:29:09.148]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:09.148]                 open = "w")
[01:29:09.148]         }
[01:29:09.148]         else {
[01:29:09.148]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:09.148]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:09.148]         }
[01:29:09.148]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:09.148]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:09.148]             base::sink(type = "output", split = FALSE)
[01:29:09.148]             base::close(...future.stdout)
[01:29:09.148]         }, add = TRUE)
[01:29:09.148]     }
[01:29:09.148]     ...future.frame <- base::sys.nframe()
[01:29:09.148]     ...future.conditions <- base::list()
[01:29:09.148]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:09.148]     if (FALSE) {
[01:29:09.148]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:09.148]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:09.148]     }
[01:29:09.148]     ...future.result <- base::tryCatch({
[01:29:09.148]         base::withCallingHandlers({
[01:29:09.148]             ...future.value <- base::withVisible(base::local({
[01:29:09.148]                 ...future.makeSendCondition <- base::local({
[01:29:09.148]                   sendCondition <- NULL
[01:29:09.148]                   function(frame = 1L) {
[01:29:09.148]                     if (is.function(sendCondition)) 
[01:29:09.148]                       return(sendCondition)
[01:29:09.148]                     ns <- getNamespace("parallel")
[01:29:09.148]                     if (exists("sendData", mode = "function", 
[01:29:09.148]                       envir = ns)) {
[01:29:09.148]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:09.148]                         envir = ns)
[01:29:09.148]                       envir <- sys.frame(frame)
[01:29:09.148]                       master <- NULL
[01:29:09.148]                       while (!identical(envir, .GlobalEnv) && 
[01:29:09.148]                         !identical(envir, emptyenv())) {
[01:29:09.148]                         if (exists("master", mode = "list", envir = envir, 
[01:29:09.148]                           inherits = FALSE)) {
[01:29:09.148]                           master <- get("master", mode = "list", 
[01:29:09.148]                             envir = envir, inherits = FALSE)
[01:29:09.148]                           if (inherits(master, c("SOCKnode", 
[01:29:09.148]                             "SOCK0node"))) {
[01:29:09.148]                             sendCondition <<- function(cond) {
[01:29:09.148]                               data <- list(type = "VALUE", value = cond, 
[01:29:09.148]                                 success = TRUE)
[01:29:09.148]                               parallel_sendData(master, data)
[01:29:09.148]                             }
[01:29:09.148]                             return(sendCondition)
[01:29:09.148]                           }
[01:29:09.148]                         }
[01:29:09.148]                         frame <- frame + 1L
[01:29:09.148]                         envir <- sys.frame(frame)
[01:29:09.148]                       }
[01:29:09.148]                     }
[01:29:09.148]                     sendCondition <<- function(cond) NULL
[01:29:09.148]                   }
[01:29:09.148]                 })
[01:29:09.148]                 withCallingHandlers({
[01:29:09.148]                   list(a = 1, b = 42L, c = stop("Nah!"))
[01:29:09.148]                 }, immediateCondition = function(cond) {
[01:29:09.148]                   sendCondition <- ...future.makeSendCondition()
[01:29:09.148]                   sendCondition(cond)
[01:29:09.148]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:09.148]                   {
[01:29:09.148]                     inherits <- base::inherits
[01:29:09.148]                     invokeRestart <- base::invokeRestart
[01:29:09.148]                     is.null <- base::is.null
[01:29:09.148]                     muffled <- FALSE
[01:29:09.148]                     if (inherits(cond, "message")) {
[01:29:09.148]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:09.148]                       if (muffled) 
[01:29:09.148]                         invokeRestart("muffleMessage")
[01:29:09.148]                     }
[01:29:09.148]                     else if (inherits(cond, "warning")) {
[01:29:09.148]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:09.148]                       if (muffled) 
[01:29:09.148]                         invokeRestart("muffleWarning")
[01:29:09.148]                     }
[01:29:09.148]                     else if (inherits(cond, "condition")) {
[01:29:09.148]                       if (!is.null(pattern)) {
[01:29:09.148]                         computeRestarts <- base::computeRestarts
[01:29:09.148]                         grepl <- base::grepl
[01:29:09.148]                         restarts <- computeRestarts(cond)
[01:29:09.148]                         for (restart in restarts) {
[01:29:09.148]                           name <- restart$name
[01:29:09.148]                           if (is.null(name)) 
[01:29:09.148]                             next
[01:29:09.148]                           if (!grepl(pattern, name)) 
[01:29:09.148]                             next
[01:29:09.148]                           invokeRestart(restart)
[01:29:09.148]                           muffled <- TRUE
[01:29:09.148]                           break
[01:29:09.148]                         }
[01:29:09.148]                       }
[01:29:09.148]                     }
[01:29:09.148]                     invisible(muffled)
[01:29:09.148]                   }
[01:29:09.148]                   muffleCondition(cond)
[01:29:09.148]                 })
[01:29:09.148]             }))
[01:29:09.148]             future::FutureResult(value = ...future.value$value, 
[01:29:09.148]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:09.148]                   ...future.rng), globalenv = if (FALSE) 
[01:29:09.148]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:09.148]                     ...future.globalenv.names))
[01:29:09.148]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:09.148]         }, condition = base::local({
[01:29:09.148]             c <- base::c
[01:29:09.148]             inherits <- base::inherits
[01:29:09.148]             invokeRestart <- base::invokeRestart
[01:29:09.148]             length <- base::length
[01:29:09.148]             list <- base::list
[01:29:09.148]             seq.int <- base::seq.int
[01:29:09.148]             signalCondition <- base::signalCondition
[01:29:09.148]             sys.calls <- base::sys.calls
[01:29:09.148]             `[[` <- base::`[[`
[01:29:09.148]             `+` <- base::`+`
[01:29:09.148]             `<<-` <- base::`<<-`
[01:29:09.148]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:09.148]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:09.148]                   3L)]
[01:29:09.148]             }
[01:29:09.148]             function(cond) {
[01:29:09.148]                 is_error <- inherits(cond, "error")
[01:29:09.148]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:09.148]                   NULL)
[01:29:09.148]                 if (is_error) {
[01:29:09.148]                   sessionInformation <- function() {
[01:29:09.148]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:09.148]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:09.148]                       search = base::search(), system = base::Sys.info())
[01:29:09.148]                   }
[01:29:09.148]                   ...future.conditions[[length(...future.conditions) + 
[01:29:09.148]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:09.148]                     cond$call), session = sessionInformation(), 
[01:29:09.148]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:09.148]                   signalCondition(cond)
[01:29:09.148]                 }
[01:29:09.148]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:09.148]                 "immediateCondition"))) {
[01:29:09.148]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:09.148]                   ...future.conditions[[length(...future.conditions) + 
[01:29:09.148]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:09.148]                   if (TRUE && !signal) {
[01:29:09.148]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:09.148]                     {
[01:29:09.148]                       inherits <- base::inherits
[01:29:09.148]                       invokeRestart <- base::invokeRestart
[01:29:09.148]                       is.null <- base::is.null
[01:29:09.148]                       muffled <- FALSE
[01:29:09.148]                       if (inherits(cond, "message")) {
[01:29:09.148]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:09.148]                         if (muffled) 
[01:29:09.148]                           invokeRestart("muffleMessage")
[01:29:09.148]                       }
[01:29:09.148]                       else if (inherits(cond, "warning")) {
[01:29:09.148]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:09.148]                         if (muffled) 
[01:29:09.148]                           invokeRestart("muffleWarning")
[01:29:09.148]                       }
[01:29:09.148]                       else if (inherits(cond, "condition")) {
[01:29:09.148]                         if (!is.null(pattern)) {
[01:29:09.148]                           computeRestarts <- base::computeRestarts
[01:29:09.148]                           grepl <- base::grepl
[01:29:09.148]                           restarts <- computeRestarts(cond)
[01:29:09.148]                           for (restart in restarts) {
[01:29:09.148]                             name <- restart$name
[01:29:09.148]                             if (is.null(name)) 
[01:29:09.148]                               next
[01:29:09.148]                             if (!grepl(pattern, name)) 
[01:29:09.148]                               next
[01:29:09.148]                             invokeRestart(restart)
[01:29:09.148]                             muffled <- TRUE
[01:29:09.148]                             break
[01:29:09.148]                           }
[01:29:09.148]                         }
[01:29:09.148]                       }
[01:29:09.148]                       invisible(muffled)
[01:29:09.148]                     }
[01:29:09.148]                     muffleCondition(cond, pattern = "^muffle")
[01:29:09.148]                   }
[01:29:09.148]                 }
[01:29:09.148]                 else {
[01:29:09.148]                   if (TRUE) {
[01:29:09.148]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:09.148]                     {
[01:29:09.148]                       inherits <- base::inherits
[01:29:09.148]                       invokeRestart <- base::invokeRestart
[01:29:09.148]                       is.null <- base::is.null
[01:29:09.148]                       muffled <- FALSE
[01:29:09.148]                       if (inherits(cond, "message")) {
[01:29:09.148]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:09.148]                         if (muffled) 
[01:29:09.148]                           invokeRestart("muffleMessage")
[01:29:09.148]                       }
[01:29:09.148]                       else if (inherits(cond, "warning")) {
[01:29:09.148]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:09.148]                         if (muffled) 
[01:29:09.148]                           invokeRestart("muffleWarning")
[01:29:09.148]                       }
[01:29:09.148]                       else if (inherits(cond, "condition")) {
[01:29:09.148]                         if (!is.null(pattern)) {
[01:29:09.148]                           computeRestarts <- base::computeRestarts
[01:29:09.148]                           grepl <- base::grepl
[01:29:09.148]                           restarts <- computeRestarts(cond)
[01:29:09.148]                           for (restart in restarts) {
[01:29:09.148]                             name <- restart$name
[01:29:09.148]                             if (is.null(name)) 
[01:29:09.148]                               next
[01:29:09.148]                             if (!grepl(pattern, name)) 
[01:29:09.148]                               next
[01:29:09.148]                             invokeRestart(restart)
[01:29:09.148]                             muffled <- TRUE
[01:29:09.148]                             break
[01:29:09.148]                           }
[01:29:09.148]                         }
[01:29:09.148]                       }
[01:29:09.148]                       invisible(muffled)
[01:29:09.148]                     }
[01:29:09.148]                     muffleCondition(cond, pattern = "^muffle")
[01:29:09.148]                   }
[01:29:09.148]                 }
[01:29:09.148]             }
[01:29:09.148]         }))
[01:29:09.148]     }, error = function(ex) {
[01:29:09.148]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:09.148]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:09.148]                 ...future.rng), started = ...future.startTime, 
[01:29:09.148]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:09.148]             version = "1.8"), class = "FutureResult")
[01:29:09.148]     }, finally = {
[01:29:09.148]         if (!identical(...future.workdir, getwd())) 
[01:29:09.148]             setwd(...future.workdir)
[01:29:09.148]         {
[01:29:09.148]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:09.148]                 ...future.oldOptions$nwarnings <- NULL
[01:29:09.148]             }
[01:29:09.148]             base::options(...future.oldOptions)
[01:29:09.148]             if (.Platform$OS.type == "windows") {
[01:29:09.148]                 old_names <- names(...future.oldEnvVars)
[01:29:09.148]                 envs <- base::Sys.getenv()
[01:29:09.148]                 names <- names(envs)
[01:29:09.148]                 common <- intersect(names, old_names)
[01:29:09.148]                 added <- setdiff(names, old_names)
[01:29:09.148]                 removed <- setdiff(old_names, names)
[01:29:09.148]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:09.148]                   envs[common]]
[01:29:09.148]                 NAMES <- toupper(changed)
[01:29:09.148]                 args <- list()
[01:29:09.148]                 for (kk in seq_along(NAMES)) {
[01:29:09.148]                   name <- changed[[kk]]
[01:29:09.148]                   NAME <- NAMES[[kk]]
[01:29:09.148]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:09.148]                     next
[01:29:09.148]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:09.148]                 }
[01:29:09.148]                 NAMES <- toupper(added)
[01:29:09.148]                 for (kk in seq_along(NAMES)) {
[01:29:09.148]                   name <- added[[kk]]
[01:29:09.148]                   NAME <- NAMES[[kk]]
[01:29:09.148]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:09.148]                     next
[01:29:09.148]                   args[[name]] <- ""
[01:29:09.148]                 }
[01:29:09.148]                 NAMES <- toupper(removed)
[01:29:09.148]                 for (kk in seq_along(NAMES)) {
[01:29:09.148]                   name <- removed[[kk]]
[01:29:09.148]                   NAME <- NAMES[[kk]]
[01:29:09.148]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:09.148]                     next
[01:29:09.148]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:09.148]                 }
[01:29:09.148]                 if (length(args) > 0) 
[01:29:09.148]                   base::do.call(base::Sys.setenv, args = args)
[01:29:09.148]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:09.148]             }
[01:29:09.148]             else {
[01:29:09.148]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:09.148]             }
[01:29:09.148]             {
[01:29:09.148]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:09.148]                   0L) {
[01:29:09.148]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:09.148]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:09.148]                   base::options(opts)
[01:29:09.148]                 }
[01:29:09.148]                 {
[01:29:09.148]                   {
[01:29:09.148]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:09.148]                     NULL
[01:29:09.148]                   }
[01:29:09.148]                   options(future.plan = NULL)
[01:29:09.148]                   if (is.na(NA_character_)) 
[01:29:09.148]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:09.148]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:09.148]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:09.148]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:09.148]                     envir = parent.frame()) 
[01:29:09.148]                   {
[01:29:09.148]                     if (is.function(workers)) 
[01:29:09.148]                       workers <- workers()
[01:29:09.148]                     workers <- structure(as.integer(workers), 
[01:29:09.148]                       class = class(workers))
[01:29:09.148]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:09.148]                       workers >= 1)
[01:29:09.148]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:09.148]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:09.148]                     }
[01:29:09.148]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:09.148]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:09.148]                       envir = envir)
[01:29:09.148]                     if (!future$lazy) 
[01:29:09.148]                       future <- run(future)
[01:29:09.148]                     invisible(future)
[01:29:09.148]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:09.148]                 }
[01:29:09.148]             }
[01:29:09.148]         }
[01:29:09.148]     })
[01:29:09.148]     if (TRUE) {
[01:29:09.148]         base::sink(type = "output", split = FALSE)
[01:29:09.148]         if (TRUE) {
[01:29:09.148]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:09.148]         }
[01:29:09.148]         else {
[01:29:09.148]             ...future.result["stdout"] <- base::list(NULL)
[01:29:09.148]         }
[01:29:09.148]         base::close(...future.stdout)
[01:29:09.148]         ...future.stdout <- NULL
[01:29:09.148]     }
[01:29:09.148]     ...future.result$conditions <- ...future.conditions
[01:29:09.148]     ...future.result$finished <- base::Sys.time()
[01:29:09.148]     ...future.result
[01:29:09.148] }
[01:29:09.156] MultisessionFuture started
[01:29:09.156] - Launch lazy future ... done
[01:29:09.156] run() for 'MultisessionFuture' ... done
[01:29:09.174] receiveMessageFromWorker() for ClusterFuture ...
[01:29:09.174] - Validating connection of MultisessionFuture
[01:29:09.175] - received message: FutureResult
[01:29:09.175] - Received FutureResult
[01:29:09.175] - Erased future from FutureRegistry
[01:29:09.175] result() for ClusterFuture ...
[01:29:09.175] - result already collected: FutureResult
[01:29:09.176] result() for ClusterFuture ... done
[01:29:09.176] signalConditions() ...
[01:29:09.176]  - include = 'immediateCondition'
[01:29:09.176]  - exclude = 
[01:29:09.176]  - resignal = FALSE
[01:29:09.176]  - Number of conditions: 1
[01:29:09.177] signalConditions() ... done
[01:29:09.177] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:09.177] A MultisessionFuture was resolved (and resolved itself)
- result = TRUE, recursive = 1 ... DONE
- result = TRUE, recursive = 2 ...
[01:29:09.177] getGlobalsAndPackages() ...
[01:29:09.178] Searching for globals...
[01:29:09.179] - globals found: [3] '{', 'Sys.sleep', 'list'
[01:29:09.179] Searching for globals ... DONE
[01:29:09.179] Resolving globals: FALSE
[01:29:09.180] 
[01:29:09.180] 
[01:29:09.180] getGlobalsAndPackages() ... DONE
[01:29:09.181] run() for 'Future' ...
[01:29:09.181] - state: 'created'
[01:29:09.181] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:09.196] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:09.196] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:09.196]   - Field: 'node'
[01:29:09.197]   - Field: 'label'
[01:29:09.197]   - Field: 'local'
[01:29:09.197]   - Field: 'owner'
[01:29:09.197]   - Field: 'envir'
[01:29:09.197]   - Field: 'workers'
[01:29:09.197]   - Field: 'packages'
[01:29:09.198]   - Field: 'gc'
[01:29:09.198]   - Field: 'conditions'
[01:29:09.198]   - Field: 'persistent'
[01:29:09.198]   - Field: 'expr'
[01:29:09.198]   - Field: 'uuid'
[01:29:09.199]   - Field: 'seed'
[01:29:09.199]   - Field: 'version'
[01:29:09.199]   - Field: 'result'
[01:29:09.199]   - Field: 'asynchronous'
[01:29:09.199]   - Field: 'calls'
[01:29:09.199]   - Field: 'globals'
[01:29:09.200]   - Field: 'stdout'
[01:29:09.200]   - Field: 'earlySignal'
[01:29:09.200]   - Field: 'lazy'
[01:29:09.200]   - Field: 'state'
[01:29:09.200] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:09.200] - Launch lazy future ...
[01:29:09.201] Packages needed by the future expression (n = 0): <none>
[01:29:09.201] Packages needed by future strategies (n = 0): <none>
[01:29:09.202] {
[01:29:09.202]     {
[01:29:09.202]         {
[01:29:09.202]             ...future.startTime <- base::Sys.time()
[01:29:09.202]             {
[01:29:09.202]                 {
[01:29:09.202]                   {
[01:29:09.202]                     {
[01:29:09.202]                       base::local({
[01:29:09.202]                         has_future <- base::requireNamespace("future", 
[01:29:09.202]                           quietly = TRUE)
[01:29:09.202]                         if (has_future) {
[01:29:09.202]                           ns <- base::getNamespace("future")
[01:29:09.202]                           version <- ns[[".package"]][["version"]]
[01:29:09.202]                           if (is.null(version)) 
[01:29:09.202]                             version <- utils::packageVersion("future")
[01:29:09.202]                         }
[01:29:09.202]                         else {
[01:29:09.202]                           version <- NULL
[01:29:09.202]                         }
[01:29:09.202]                         if (!has_future || version < "1.8.0") {
[01:29:09.202]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:09.202]                             "", base::R.version$version.string), 
[01:29:09.202]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:09.202]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:09.202]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:09.202]                               "release", "version")], collapse = " "), 
[01:29:09.202]                             hostname = base::Sys.info()[["nodename"]])
[01:29:09.202]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:09.202]                             info)
[01:29:09.202]                           info <- base::paste(info, collapse = "; ")
[01:29:09.202]                           if (!has_future) {
[01:29:09.202]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:09.202]                               info)
[01:29:09.202]                           }
[01:29:09.202]                           else {
[01:29:09.202]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:09.202]                               info, version)
[01:29:09.202]                           }
[01:29:09.202]                           base::stop(msg)
[01:29:09.202]                         }
[01:29:09.202]                       })
[01:29:09.202]                     }
[01:29:09.202]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:09.202]                     base::options(mc.cores = 1L)
[01:29:09.202]                   }
[01:29:09.202]                   options(future.plan = NULL)
[01:29:09.202]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:09.202]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:09.202]                 }
[01:29:09.202]                 ...future.workdir <- getwd()
[01:29:09.202]             }
[01:29:09.202]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:09.202]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:09.202]         }
[01:29:09.202]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:09.202]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:09.202]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:09.202]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:09.202]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:09.202]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:09.202]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:09.202]             base::names(...future.oldOptions))
[01:29:09.202]     }
[01:29:09.202]     if (FALSE) {
[01:29:09.202]     }
[01:29:09.202]     else {
[01:29:09.202]         if (TRUE) {
[01:29:09.202]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:09.202]                 open = "w")
[01:29:09.202]         }
[01:29:09.202]         else {
[01:29:09.202]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:09.202]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:09.202]         }
[01:29:09.202]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:09.202]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:09.202]             base::sink(type = "output", split = FALSE)
[01:29:09.202]             base::close(...future.stdout)
[01:29:09.202]         }, add = TRUE)
[01:29:09.202]     }
[01:29:09.202]     ...future.frame <- base::sys.nframe()
[01:29:09.202]     ...future.conditions <- base::list()
[01:29:09.202]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:09.202]     if (FALSE) {
[01:29:09.202]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:09.202]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:09.202]     }
[01:29:09.202]     ...future.result <- base::tryCatch({
[01:29:09.202]         base::withCallingHandlers({
[01:29:09.202]             ...future.value <- base::withVisible(base::local({
[01:29:09.202]                 ...future.makeSendCondition <- base::local({
[01:29:09.202]                   sendCondition <- NULL
[01:29:09.202]                   function(frame = 1L) {
[01:29:09.202]                     if (is.function(sendCondition)) 
[01:29:09.202]                       return(sendCondition)
[01:29:09.202]                     ns <- getNamespace("parallel")
[01:29:09.202]                     if (exists("sendData", mode = "function", 
[01:29:09.202]                       envir = ns)) {
[01:29:09.202]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:09.202]                         envir = ns)
[01:29:09.202]                       envir <- sys.frame(frame)
[01:29:09.202]                       master <- NULL
[01:29:09.202]                       while (!identical(envir, .GlobalEnv) && 
[01:29:09.202]                         !identical(envir, emptyenv())) {
[01:29:09.202]                         if (exists("master", mode = "list", envir = envir, 
[01:29:09.202]                           inherits = FALSE)) {
[01:29:09.202]                           master <- get("master", mode = "list", 
[01:29:09.202]                             envir = envir, inherits = FALSE)
[01:29:09.202]                           if (inherits(master, c("SOCKnode", 
[01:29:09.202]                             "SOCK0node"))) {
[01:29:09.202]                             sendCondition <<- function(cond) {
[01:29:09.202]                               data <- list(type = "VALUE", value = cond, 
[01:29:09.202]                                 success = TRUE)
[01:29:09.202]                               parallel_sendData(master, data)
[01:29:09.202]                             }
[01:29:09.202]                             return(sendCondition)
[01:29:09.202]                           }
[01:29:09.202]                         }
[01:29:09.202]                         frame <- frame + 1L
[01:29:09.202]                         envir <- sys.frame(frame)
[01:29:09.202]                       }
[01:29:09.202]                     }
[01:29:09.202]                     sendCondition <<- function(cond) NULL
[01:29:09.202]                   }
[01:29:09.202]                 })
[01:29:09.202]                 withCallingHandlers({
[01:29:09.202]                   {
[01:29:09.202]                     Sys.sleep(0.5)
[01:29:09.202]                     list(a = 1, b = 42L)
[01:29:09.202]                   }
[01:29:09.202]                 }, immediateCondition = function(cond) {
[01:29:09.202]                   sendCondition <- ...future.makeSendCondition()
[01:29:09.202]                   sendCondition(cond)
[01:29:09.202]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:09.202]                   {
[01:29:09.202]                     inherits <- base::inherits
[01:29:09.202]                     invokeRestart <- base::invokeRestart
[01:29:09.202]                     is.null <- base::is.null
[01:29:09.202]                     muffled <- FALSE
[01:29:09.202]                     if (inherits(cond, "message")) {
[01:29:09.202]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:09.202]                       if (muffled) 
[01:29:09.202]                         invokeRestart("muffleMessage")
[01:29:09.202]                     }
[01:29:09.202]                     else if (inherits(cond, "warning")) {
[01:29:09.202]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:09.202]                       if (muffled) 
[01:29:09.202]                         invokeRestart("muffleWarning")
[01:29:09.202]                     }
[01:29:09.202]                     else if (inherits(cond, "condition")) {
[01:29:09.202]                       if (!is.null(pattern)) {
[01:29:09.202]                         computeRestarts <- base::computeRestarts
[01:29:09.202]                         grepl <- base::grepl
[01:29:09.202]                         restarts <- computeRestarts(cond)
[01:29:09.202]                         for (restart in restarts) {
[01:29:09.202]                           name <- restart$name
[01:29:09.202]                           if (is.null(name)) 
[01:29:09.202]                             next
[01:29:09.202]                           if (!grepl(pattern, name)) 
[01:29:09.202]                             next
[01:29:09.202]                           invokeRestart(restart)
[01:29:09.202]                           muffled <- TRUE
[01:29:09.202]                           break
[01:29:09.202]                         }
[01:29:09.202]                       }
[01:29:09.202]                     }
[01:29:09.202]                     invisible(muffled)
[01:29:09.202]                   }
[01:29:09.202]                   muffleCondition(cond)
[01:29:09.202]                 })
[01:29:09.202]             }))
[01:29:09.202]             future::FutureResult(value = ...future.value$value, 
[01:29:09.202]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:09.202]                   ...future.rng), globalenv = if (FALSE) 
[01:29:09.202]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:09.202]                     ...future.globalenv.names))
[01:29:09.202]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:09.202]         }, condition = base::local({
[01:29:09.202]             c <- base::c
[01:29:09.202]             inherits <- base::inherits
[01:29:09.202]             invokeRestart <- base::invokeRestart
[01:29:09.202]             length <- base::length
[01:29:09.202]             list <- base::list
[01:29:09.202]             seq.int <- base::seq.int
[01:29:09.202]             signalCondition <- base::signalCondition
[01:29:09.202]             sys.calls <- base::sys.calls
[01:29:09.202]             `[[` <- base::`[[`
[01:29:09.202]             `+` <- base::`+`
[01:29:09.202]             `<<-` <- base::`<<-`
[01:29:09.202]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:09.202]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:09.202]                   3L)]
[01:29:09.202]             }
[01:29:09.202]             function(cond) {
[01:29:09.202]                 is_error <- inherits(cond, "error")
[01:29:09.202]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:09.202]                   NULL)
[01:29:09.202]                 if (is_error) {
[01:29:09.202]                   sessionInformation <- function() {
[01:29:09.202]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:09.202]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:09.202]                       search = base::search(), system = base::Sys.info())
[01:29:09.202]                   }
[01:29:09.202]                   ...future.conditions[[length(...future.conditions) + 
[01:29:09.202]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:09.202]                     cond$call), session = sessionInformation(), 
[01:29:09.202]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:09.202]                   signalCondition(cond)
[01:29:09.202]                 }
[01:29:09.202]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:09.202]                 "immediateCondition"))) {
[01:29:09.202]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:09.202]                   ...future.conditions[[length(...future.conditions) + 
[01:29:09.202]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:09.202]                   if (TRUE && !signal) {
[01:29:09.202]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:09.202]                     {
[01:29:09.202]                       inherits <- base::inherits
[01:29:09.202]                       invokeRestart <- base::invokeRestart
[01:29:09.202]                       is.null <- base::is.null
[01:29:09.202]                       muffled <- FALSE
[01:29:09.202]                       if (inherits(cond, "message")) {
[01:29:09.202]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:09.202]                         if (muffled) 
[01:29:09.202]                           invokeRestart("muffleMessage")
[01:29:09.202]                       }
[01:29:09.202]                       else if (inherits(cond, "warning")) {
[01:29:09.202]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:09.202]                         if (muffled) 
[01:29:09.202]                           invokeRestart("muffleWarning")
[01:29:09.202]                       }
[01:29:09.202]                       else if (inherits(cond, "condition")) {
[01:29:09.202]                         if (!is.null(pattern)) {
[01:29:09.202]                           computeRestarts <- base::computeRestarts
[01:29:09.202]                           grepl <- base::grepl
[01:29:09.202]                           restarts <- computeRestarts(cond)
[01:29:09.202]                           for (restart in restarts) {
[01:29:09.202]                             name <- restart$name
[01:29:09.202]                             if (is.null(name)) 
[01:29:09.202]                               next
[01:29:09.202]                             if (!grepl(pattern, name)) 
[01:29:09.202]                               next
[01:29:09.202]                             invokeRestart(restart)
[01:29:09.202]                             muffled <- TRUE
[01:29:09.202]                             break
[01:29:09.202]                           }
[01:29:09.202]                         }
[01:29:09.202]                       }
[01:29:09.202]                       invisible(muffled)
[01:29:09.202]                     }
[01:29:09.202]                     muffleCondition(cond, pattern = "^muffle")
[01:29:09.202]                   }
[01:29:09.202]                 }
[01:29:09.202]                 else {
[01:29:09.202]                   if (TRUE) {
[01:29:09.202]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:09.202]                     {
[01:29:09.202]                       inherits <- base::inherits
[01:29:09.202]                       invokeRestart <- base::invokeRestart
[01:29:09.202]                       is.null <- base::is.null
[01:29:09.202]                       muffled <- FALSE
[01:29:09.202]                       if (inherits(cond, "message")) {
[01:29:09.202]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:09.202]                         if (muffled) 
[01:29:09.202]                           invokeRestart("muffleMessage")
[01:29:09.202]                       }
[01:29:09.202]                       else if (inherits(cond, "warning")) {
[01:29:09.202]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:09.202]                         if (muffled) 
[01:29:09.202]                           invokeRestart("muffleWarning")
[01:29:09.202]                       }
[01:29:09.202]                       else if (inherits(cond, "condition")) {
[01:29:09.202]                         if (!is.null(pattern)) {
[01:29:09.202]                           computeRestarts <- base::computeRestarts
[01:29:09.202]                           grepl <- base::grepl
[01:29:09.202]                           restarts <- computeRestarts(cond)
[01:29:09.202]                           for (restart in restarts) {
[01:29:09.202]                             name <- restart$name
[01:29:09.202]                             if (is.null(name)) 
[01:29:09.202]                               next
[01:29:09.202]                             if (!grepl(pattern, name)) 
[01:29:09.202]                               next
[01:29:09.202]                             invokeRestart(restart)
[01:29:09.202]                             muffled <- TRUE
[01:29:09.202]                             break
[01:29:09.202]                           }
[01:29:09.202]                         }
[01:29:09.202]                       }
[01:29:09.202]                       invisible(muffled)
[01:29:09.202]                     }
[01:29:09.202]                     muffleCondition(cond, pattern = "^muffle")
[01:29:09.202]                   }
[01:29:09.202]                 }
[01:29:09.202]             }
[01:29:09.202]         }))
[01:29:09.202]     }, error = function(ex) {
[01:29:09.202]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:09.202]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:09.202]                 ...future.rng), started = ...future.startTime, 
[01:29:09.202]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:09.202]             version = "1.8"), class = "FutureResult")
[01:29:09.202]     }, finally = {
[01:29:09.202]         if (!identical(...future.workdir, getwd())) 
[01:29:09.202]             setwd(...future.workdir)
[01:29:09.202]         {
[01:29:09.202]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:09.202]                 ...future.oldOptions$nwarnings <- NULL
[01:29:09.202]             }
[01:29:09.202]             base::options(...future.oldOptions)
[01:29:09.202]             if (.Platform$OS.type == "windows") {
[01:29:09.202]                 old_names <- names(...future.oldEnvVars)
[01:29:09.202]                 envs <- base::Sys.getenv()
[01:29:09.202]                 names <- names(envs)
[01:29:09.202]                 common <- intersect(names, old_names)
[01:29:09.202]                 added <- setdiff(names, old_names)
[01:29:09.202]                 removed <- setdiff(old_names, names)
[01:29:09.202]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:09.202]                   envs[common]]
[01:29:09.202]                 NAMES <- toupper(changed)
[01:29:09.202]                 args <- list()
[01:29:09.202]                 for (kk in seq_along(NAMES)) {
[01:29:09.202]                   name <- changed[[kk]]
[01:29:09.202]                   NAME <- NAMES[[kk]]
[01:29:09.202]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:09.202]                     next
[01:29:09.202]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:09.202]                 }
[01:29:09.202]                 NAMES <- toupper(added)
[01:29:09.202]                 for (kk in seq_along(NAMES)) {
[01:29:09.202]                   name <- added[[kk]]
[01:29:09.202]                   NAME <- NAMES[[kk]]
[01:29:09.202]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:09.202]                     next
[01:29:09.202]                   args[[name]] <- ""
[01:29:09.202]                 }
[01:29:09.202]                 NAMES <- toupper(removed)
[01:29:09.202]                 for (kk in seq_along(NAMES)) {
[01:29:09.202]                   name <- removed[[kk]]
[01:29:09.202]                   NAME <- NAMES[[kk]]
[01:29:09.202]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:09.202]                     next
[01:29:09.202]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:09.202]                 }
[01:29:09.202]                 if (length(args) > 0) 
[01:29:09.202]                   base::do.call(base::Sys.setenv, args = args)
[01:29:09.202]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:09.202]             }
[01:29:09.202]             else {
[01:29:09.202]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:09.202]             }
[01:29:09.202]             {
[01:29:09.202]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:09.202]                   0L) {
[01:29:09.202]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:09.202]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:09.202]                   base::options(opts)
[01:29:09.202]                 }
[01:29:09.202]                 {
[01:29:09.202]                   {
[01:29:09.202]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:09.202]                     NULL
[01:29:09.202]                   }
[01:29:09.202]                   options(future.plan = NULL)
[01:29:09.202]                   if (is.na(NA_character_)) 
[01:29:09.202]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:09.202]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:09.202]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:09.202]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:09.202]                     envir = parent.frame()) 
[01:29:09.202]                   {
[01:29:09.202]                     if (is.function(workers)) 
[01:29:09.202]                       workers <- workers()
[01:29:09.202]                     workers <- structure(as.integer(workers), 
[01:29:09.202]                       class = class(workers))
[01:29:09.202]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:09.202]                       workers >= 1)
[01:29:09.202]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:09.202]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:09.202]                     }
[01:29:09.202]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:09.202]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:09.202]                       envir = envir)
[01:29:09.202]                     if (!future$lazy) 
[01:29:09.202]                       future <- run(future)
[01:29:09.202]                     invisible(future)
[01:29:09.202]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:09.202]                 }
[01:29:09.202]             }
[01:29:09.202]         }
[01:29:09.202]     })
[01:29:09.202]     if (TRUE) {
[01:29:09.202]         base::sink(type = "output", split = FALSE)
[01:29:09.202]         if (TRUE) {
[01:29:09.202]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:09.202]         }
[01:29:09.202]         else {
[01:29:09.202]             ...future.result["stdout"] <- base::list(NULL)
[01:29:09.202]         }
[01:29:09.202]         base::close(...future.stdout)
[01:29:09.202]         ...future.stdout <- NULL
[01:29:09.202]     }
[01:29:09.202]     ...future.result$conditions <- ...future.conditions
[01:29:09.202]     ...future.result$finished <- base::Sys.time()
[01:29:09.202]     ...future.result
[01:29:09.202] }
[01:29:09.208] MultisessionFuture started
[01:29:09.209] - Launch lazy future ... done
[01:29:09.209] run() for 'MultisessionFuture' ... done
[01:29:09.735] receiveMessageFromWorker() for ClusterFuture ...
[01:29:09.736] - Validating connection of MultisessionFuture
[01:29:09.736] - received message: FutureResult
[01:29:09.736] - Received FutureResult
[01:29:09.737] - Erased future from FutureRegistry
[01:29:09.737] result() for ClusterFuture ...
[01:29:09.737] - result already collected: FutureResult
[01:29:09.737] result() for ClusterFuture ... done
[01:29:09.737] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:09.737] resolve() on list ...
[01:29:09.738]  recursive: 1
[01:29:09.738]  length: 2
[01:29:09.738]  elements: 'a', 'b'
[01:29:09.738]  length: 1 (resolved future 1)
[01:29:09.738]  length: 0 (resolved future 2)
[01:29:09.739] resolve() on list ... DONE
[01:29:09.739] A MultisessionFuture was resolved (and resolved itself)
[01:29:09.739] getGlobalsAndPackages() ...
[01:29:09.739] Searching for globals...
[01:29:09.741] - globals found: [3] '{', 'Sys.sleep', 'list'
[01:29:09.741] Searching for globals ... DONE
[01:29:09.741] Resolving globals: FALSE
[01:29:09.742] 
[01:29:09.742] 
[01:29:09.742] getGlobalsAndPackages() ... DONE
[01:29:09.742] run() for 'Future' ...
[01:29:09.742] - state: 'created'
[01:29:09.743] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:09.758] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:09.758] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:09.758]   - Field: 'node'
[01:29:09.758]   - Field: 'label'
[01:29:09.758]   - Field: 'local'
[01:29:09.759]   - Field: 'owner'
[01:29:09.759]   - Field: 'envir'
[01:29:09.759]   - Field: 'workers'
[01:29:09.759]   - Field: 'packages'
[01:29:09.759]   - Field: 'gc'
[01:29:09.760]   - Field: 'conditions'
[01:29:09.760]   - Field: 'persistent'
[01:29:09.760]   - Field: 'expr'
[01:29:09.760]   - Field: 'uuid'
[01:29:09.760]   - Field: 'seed'
[01:29:09.760]   - Field: 'version'
[01:29:09.761]   - Field: 'result'
[01:29:09.761]   - Field: 'asynchronous'
[01:29:09.761]   - Field: 'calls'
[01:29:09.761]   - Field: 'globals'
[01:29:09.761]   - Field: 'stdout'
[01:29:09.762]   - Field: 'earlySignal'
[01:29:09.762]   - Field: 'lazy'
[01:29:09.762]   - Field: 'state'
[01:29:09.762] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:09.762] - Launch lazy future ...
[01:29:09.766] Packages needed by the future expression (n = 0): <none>
[01:29:09.766] Packages needed by future strategies (n = 0): <none>
[01:29:09.767] {
[01:29:09.767]     {
[01:29:09.767]         {
[01:29:09.767]             ...future.startTime <- base::Sys.time()
[01:29:09.767]             {
[01:29:09.767]                 {
[01:29:09.767]                   {
[01:29:09.767]                     {
[01:29:09.767]                       base::local({
[01:29:09.767]                         has_future <- base::requireNamespace("future", 
[01:29:09.767]                           quietly = TRUE)
[01:29:09.767]                         if (has_future) {
[01:29:09.767]                           ns <- base::getNamespace("future")
[01:29:09.767]                           version <- ns[[".package"]][["version"]]
[01:29:09.767]                           if (is.null(version)) 
[01:29:09.767]                             version <- utils::packageVersion("future")
[01:29:09.767]                         }
[01:29:09.767]                         else {
[01:29:09.767]                           version <- NULL
[01:29:09.767]                         }
[01:29:09.767]                         if (!has_future || version < "1.8.0") {
[01:29:09.767]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:09.767]                             "", base::R.version$version.string), 
[01:29:09.767]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:09.767]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:09.767]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:09.767]                               "release", "version")], collapse = " "), 
[01:29:09.767]                             hostname = base::Sys.info()[["nodename"]])
[01:29:09.767]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:09.767]                             info)
[01:29:09.767]                           info <- base::paste(info, collapse = "; ")
[01:29:09.767]                           if (!has_future) {
[01:29:09.767]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:09.767]                               info)
[01:29:09.767]                           }
[01:29:09.767]                           else {
[01:29:09.767]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:09.767]                               info, version)
[01:29:09.767]                           }
[01:29:09.767]                           base::stop(msg)
[01:29:09.767]                         }
[01:29:09.767]                       })
[01:29:09.767]                     }
[01:29:09.767]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:09.767]                     base::options(mc.cores = 1L)
[01:29:09.767]                   }
[01:29:09.767]                   options(future.plan = NULL)
[01:29:09.767]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:09.767]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:09.767]                 }
[01:29:09.767]                 ...future.workdir <- getwd()
[01:29:09.767]             }
[01:29:09.767]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:09.767]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:09.767]         }
[01:29:09.767]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:09.767]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:09.767]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:09.767]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:09.767]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:09.767]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:09.767]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:09.767]             base::names(...future.oldOptions))
[01:29:09.767]     }
[01:29:09.767]     if (FALSE) {
[01:29:09.767]     }
[01:29:09.767]     else {
[01:29:09.767]         if (TRUE) {
[01:29:09.767]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:09.767]                 open = "w")
[01:29:09.767]         }
[01:29:09.767]         else {
[01:29:09.767]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:09.767]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:09.767]         }
[01:29:09.767]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:09.767]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:09.767]             base::sink(type = "output", split = FALSE)
[01:29:09.767]             base::close(...future.stdout)
[01:29:09.767]         }, add = TRUE)
[01:29:09.767]     }
[01:29:09.767]     ...future.frame <- base::sys.nframe()
[01:29:09.767]     ...future.conditions <- base::list()
[01:29:09.767]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:09.767]     if (FALSE) {
[01:29:09.767]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:09.767]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:09.767]     }
[01:29:09.767]     ...future.result <- base::tryCatch({
[01:29:09.767]         base::withCallingHandlers({
[01:29:09.767]             ...future.value <- base::withVisible(base::local({
[01:29:09.767]                 ...future.makeSendCondition <- base::local({
[01:29:09.767]                   sendCondition <- NULL
[01:29:09.767]                   function(frame = 1L) {
[01:29:09.767]                     if (is.function(sendCondition)) 
[01:29:09.767]                       return(sendCondition)
[01:29:09.767]                     ns <- getNamespace("parallel")
[01:29:09.767]                     if (exists("sendData", mode = "function", 
[01:29:09.767]                       envir = ns)) {
[01:29:09.767]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:09.767]                         envir = ns)
[01:29:09.767]                       envir <- sys.frame(frame)
[01:29:09.767]                       master <- NULL
[01:29:09.767]                       while (!identical(envir, .GlobalEnv) && 
[01:29:09.767]                         !identical(envir, emptyenv())) {
[01:29:09.767]                         if (exists("master", mode = "list", envir = envir, 
[01:29:09.767]                           inherits = FALSE)) {
[01:29:09.767]                           master <- get("master", mode = "list", 
[01:29:09.767]                             envir = envir, inherits = FALSE)
[01:29:09.767]                           if (inherits(master, c("SOCKnode", 
[01:29:09.767]                             "SOCK0node"))) {
[01:29:09.767]                             sendCondition <<- function(cond) {
[01:29:09.767]                               data <- list(type = "VALUE", value = cond, 
[01:29:09.767]                                 success = TRUE)
[01:29:09.767]                               parallel_sendData(master, data)
[01:29:09.767]                             }
[01:29:09.767]                             return(sendCondition)
[01:29:09.767]                           }
[01:29:09.767]                         }
[01:29:09.767]                         frame <- frame + 1L
[01:29:09.767]                         envir <- sys.frame(frame)
[01:29:09.767]                       }
[01:29:09.767]                     }
[01:29:09.767]                     sendCondition <<- function(cond) NULL
[01:29:09.767]                   }
[01:29:09.767]                 })
[01:29:09.767]                 withCallingHandlers({
[01:29:09.767]                   {
[01:29:09.767]                     Sys.sleep(0.5)
[01:29:09.767]                     list(a = 1, b = 42L)
[01:29:09.767]                   }
[01:29:09.767]                 }, immediateCondition = function(cond) {
[01:29:09.767]                   sendCondition <- ...future.makeSendCondition()
[01:29:09.767]                   sendCondition(cond)
[01:29:09.767]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:09.767]                   {
[01:29:09.767]                     inherits <- base::inherits
[01:29:09.767]                     invokeRestart <- base::invokeRestart
[01:29:09.767]                     is.null <- base::is.null
[01:29:09.767]                     muffled <- FALSE
[01:29:09.767]                     if (inherits(cond, "message")) {
[01:29:09.767]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:09.767]                       if (muffled) 
[01:29:09.767]                         invokeRestart("muffleMessage")
[01:29:09.767]                     }
[01:29:09.767]                     else if (inherits(cond, "warning")) {
[01:29:09.767]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:09.767]                       if (muffled) 
[01:29:09.767]                         invokeRestart("muffleWarning")
[01:29:09.767]                     }
[01:29:09.767]                     else if (inherits(cond, "condition")) {
[01:29:09.767]                       if (!is.null(pattern)) {
[01:29:09.767]                         computeRestarts <- base::computeRestarts
[01:29:09.767]                         grepl <- base::grepl
[01:29:09.767]                         restarts <- computeRestarts(cond)
[01:29:09.767]                         for (restart in restarts) {
[01:29:09.767]                           name <- restart$name
[01:29:09.767]                           if (is.null(name)) 
[01:29:09.767]                             next
[01:29:09.767]                           if (!grepl(pattern, name)) 
[01:29:09.767]                             next
[01:29:09.767]                           invokeRestart(restart)
[01:29:09.767]                           muffled <- TRUE
[01:29:09.767]                           break
[01:29:09.767]                         }
[01:29:09.767]                       }
[01:29:09.767]                     }
[01:29:09.767]                     invisible(muffled)
[01:29:09.767]                   }
[01:29:09.767]                   muffleCondition(cond)
[01:29:09.767]                 })
[01:29:09.767]             }))
[01:29:09.767]             future::FutureResult(value = ...future.value$value, 
[01:29:09.767]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:09.767]                   ...future.rng), globalenv = if (FALSE) 
[01:29:09.767]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:09.767]                     ...future.globalenv.names))
[01:29:09.767]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:09.767]         }, condition = base::local({
[01:29:09.767]             c <- base::c
[01:29:09.767]             inherits <- base::inherits
[01:29:09.767]             invokeRestart <- base::invokeRestart
[01:29:09.767]             length <- base::length
[01:29:09.767]             list <- base::list
[01:29:09.767]             seq.int <- base::seq.int
[01:29:09.767]             signalCondition <- base::signalCondition
[01:29:09.767]             sys.calls <- base::sys.calls
[01:29:09.767]             `[[` <- base::`[[`
[01:29:09.767]             `+` <- base::`+`
[01:29:09.767]             `<<-` <- base::`<<-`
[01:29:09.767]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:09.767]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:09.767]                   3L)]
[01:29:09.767]             }
[01:29:09.767]             function(cond) {
[01:29:09.767]                 is_error <- inherits(cond, "error")
[01:29:09.767]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:09.767]                   NULL)
[01:29:09.767]                 if (is_error) {
[01:29:09.767]                   sessionInformation <- function() {
[01:29:09.767]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:09.767]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:09.767]                       search = base::search(), system = base::Sys.info())
[01:29:09.767]                   }
[01:29:09.767]                   ...future.conditions[[length(...future.conditions) + 
[01:29:09.767]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:09.767]                     cond$call), session = sessionInformation(), 
[01:29:09.767]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:09.767]                   signalCondition(cond)
[01:29:09.767]                 }
[01:29:09.767]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:09.767]                 "immediateCondition"))) {
[01:29:09.767]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:09.767]                   ...future.conditions[[length(...future.conditions) + 
[01:29:09.767]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:09.767]                   if (TRUE && !signal) {
[01:29:09.767]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:09.767]                     {
[01:29:09.767]                       inherits <- base::inherits
[01:29:09.767]                       invokeRestart <- base::invokeRestart
[01:29:09.767]                       is.null <- base::is.null
[01:29:09.767]                       muffled <- FALSE
[01:29:09.767]                       if (inherits(cond, "message")) {
[01:29:09.767]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:09.767]                         if (muffled) 
[01:29:09.767]                           invokeRestart("muffleMessage")
[01:29:09.767]                       }
[01:29:09.767]                       else if (inherits(cond, "warning")) {
[01:29:09.767]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:09.767]                         if (muffled) 
[01:29:09.767]                           invokeRestart("muffleWarning")
[01:29:09.767]                       }
[01:29:09.767]                       else if (inherits(cond, "condition")) {
[01:29:09.767]                         if (!is.null(pattern)) {
[01:29:09.767]                           computeRestarts <- base::computeRestarts
[01:29:09.767]                           grepl <- base::grepl
[01:29:09.767]                           restarts <- computeRestarts(cond)
[01:29:09.767]                           for (restart in restarts) {
[01:29:09.767]                             name <- restart$name
[01:29:09.767]                             if (is.null(name)) 
[01:29:09.767]                               next
[01:29:09.767]                             if (!grepl(pattern, name)) 
[01:29:09.767]                               next
[01:29:09.767]                             invokeRestart(restart)
[01:29:09.767]                             muffled <- TRUE
[01:29:09.767]                             break
[01:29:09.767]                           }
[01:29:09.767]                         }
[01:29:09.767]                       }
[01:29:09.767]                       invisible(muffled)
[01:29:09.767]                     }
[01:29:09.767]                     muffleCondition(cond, pattern = "^muffle")
[01:29:09.767]                   }
[01:29:09.767]                 }
[01:29:09.767]                 else {
[01:29:09.767]                   if (TRUE) {
[01:29:09.767]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:09.767]                     {
[01:29:09.767]                       inherits <- base::inherits
[01:29:09.767]                       invokeRestart <- base::invokeRestart
[01:29:09.767]                       is.null <- base::is.null
[01:29:09.767]                       muffled <- FALSE
[01:29:09.767]                       if (inherits(cond, "message")) {
[01:29:09.767]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:09.767]                         if (muffled) 
[01:29:09.767]                           invokeRestart("muffleMessage")
[01:29:09.767]                       }
[01:29:09.767]                       else if (inherits(cond, "warning")) {
[01:29:09.767]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:09.767]                         if (muffled) 
[01:29:09.767]                           invokeRestart("muffleWarning")
[01:29:09.767]                       }
[01:29:09.767]                       else if (inherits(cond, "condition")) {
[01:29:09.767]                         if (!is.null(pattern)) {
[01:29:09.767]                           computeRestarts <- base::computeRestarts
[01:29:09.767]                           grepl <- base::grepl
[01:29:09.767]                           restarts <- computeRestarts(cond)
[01:29:09.767]                           for (restart in restarts) {
[01:29:09.767]                             name <- restart$name
[01:29:09.767]                             if (is.null(name)) 
[01:29:09.767]                               next
[01:29:09.767]                             if (!grepl(pattern, name)) 
[01:29:09.767]                               next
[01:29:09.767]                             invokeRestart(restart)
[01:29:09.767]                             muffled <- TRUE
[01:29:09.767]                             break
[01:29:09.767]                           }
[01:29:09.767]                         }
[01:29:09.767]                       }
[01:29:09.767]                       invisible(muffled)
[01:29:09.767]                     }
[01:29:09.767]                     muffleCondition(cond, pattern = "^muffle")
[01:29:09.767]                   }
[01:29:09.767]                 }
[01:29:09.767]             }
[01:29:09.767]         }))
[01:29:09.767]     }, error = function(ex) {
[01:29:09.767]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:09.767]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:09.767]                 ...future.rng), started = ...future.startTime, 
[01:29:09.767]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:09.767]             version = "1.8"), class = "FutureResult")
[01:29:09.767]     }, finally = {
[01:29:09.767]         if (!identical(...future.workdir, getwd())) 
[01:29:09.767]             setwd(...future.workdir)
[01:29:09.767]         {
[01:29:09.767]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:09.767]                 ...future.oldOptions$nwarnings <- NULL
[01:29:09.767]             }
[01:29:09.767]             base::options(...future.oldOptions)
[01:29:09.767]             if (.Platform$OS.type == "windows") {
[01:29:09.767]                 old_names <- names(...future.oldEnvVars)
[01:29:09.767]                 envs <- base::Sys.getenv()
[01:29:09.767]                 names <- names(envs)
[01:29:09.767]                 common <- intersect(names, old_names)
[01:29:09.767]                 added <- setdiff(names, old_names)
[01:29:09.767]                 removed <- setdiff(old_names, names)
[01:29:09.767]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:09.767]                   envs[common]]
[01:29:09.767]                 NAMES <- toupper(changed)
[01:29:09.767]                 args <- list()
[01:29:09.767]                 for (kk in seq_along(NAMES)) {
[01:29:09.767]                   name <- changed[[kk]]
[01:29:09.767]                   NAME <- NAMES[[kk]]
[01:29:09.767]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:09.767]                     next
[01:29:09.767]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:09.767]                 }
[01:29:09.767]                 NAMES <- toupper(added)
[01:29:09.767]                 for (kk in seq_along(NAMES)) {
[01:29:09.767]                   name <- added[[kk]]
[01:29:09.767]                   NAME <- NAMES[[kk]]
[01:29:09.767]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:09.767]                     next
[01:29:09.767]                   args[[name]] <- ""
[01:29:09.767]                 }
[01:29:09.767]                 NAMES <- toupper(removed)
[01:29:09.767]                 for (kk in seq_along(NAMES)) {
[01:29:09.767]                   name <- removed[[kk]]
[01:29:09.767]                   NAME <- NAMES[[kk]]
[01:29:09.767]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:09.767]                     next
[01:29:09.767]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:09.767]                 }
[01:29:09.767]                 if (length(args) > 0) 
[01:29:09.767]                   base::do.call(base::Sys.setenv, args = args)
[01:29:09.767]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:09.767]             }
[01:29:09.767]             else {
[01:29:09.767]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:09.767]             }
[01:29:09.767]             {
[01:29:09.767]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:09.767]                   0L) {
[01:29:09.767]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:09.767]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:09.767]                   base::options(opts)
[01:29:09.767]                 }
[01:29:09.767]                 {
[01:29:09.767]                   {
[01:29:09.767]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:09.767]                     NULL
[01:29:09.767]                   }
[01:29:09.767]                   options(future.plan = NULL)
[01:29:09.767]                   if (is.na(NA_character_)) 
[01:29:09.767]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:09.767]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:09.767]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:09.767]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:09.767]                     envir = parent.frame()) 
[01:29:09.767]                   {
[01:29:09.767]                     if (is.function(workers)) 
[01:29:09.767]                       workers <- workers()
[01:29:09.767]                     workers <- structure(as.integer(workers), 
[01:29:09.767]                       class = class(workers))
[01:29:09.767]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:09.767]                       workers >= 1)
[01:29:09.767]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:09.767]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:09.767]                     }
[01:29:09.767]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:09.767]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:09.767]                       envir = envir)
[01:29:09.767]                     if (!future$lazy) 
[01:29:09.767]                       future <- run(future)
[01:29:09.767]                     invisible(future)
[01:29:09.767]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:09.767]                 }
[01:29:09.767]             }
[01:29:09.767]         }
[01:29:09.767]     })
[01:29:09.767]     if (TRUE) {
[01:29:09.767]         base::sink(type = "output", split = FALSE)
[01:29:09.767]         if (TRUE) {
[01:29:09.767]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:09.767]         }
[01:29:09.767]         else {
[01:29:09.767]             ...future.result["stdout"] <- base::list(NULL)
[01:29:09.767]         }
[01:29:09.767]         base::close(...future.stdout)
[01:29:09.767]         ...future.stdout <- NULL
[01:29:09.767]     }
[01:29:09.767]     ...future.result$conditions <- ...future.conditions
[01:29:09.767]     ...future.result$finished <- base::Sys.time()
[01:29:09.767]     ...future.result
[01:29:09.767] }
[01:29:09.773] MultisessionFuture started
[01:29:09.773] - Launch lazy future ... done
[01:29:09.773] run() for 'MultisessionFuture' ... done
[01:29:10.306] receiveMessageFromWorker() for ClusterFuture ...
[01:29:10.307] - Validating connection of MultisessionFuture
[01:29:10.307] - received message: FutureResult
[01:29:10.307] - Received FutureResult
[01:29:10.308] - Erased future from FutureRegistry
[01:29:10.308] result() for ClusterFuture ...
[01:29:10.308] - result already collected: FutureResult
[01:29:10.308] result() for ClusterFuture ... done
[01:29:10.308] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:10.309] resolve() on list ...
[01:29:10.309]  recursive: 1
[01:29:10.309]  length: 2
[01:29:10.309]  elements: 'a', 'b'
[01:29:10.309]  length: 1 (resolved future 1)
[01:29:10.309]  length: 0 (resolved future 2)
[01:29:10.310] resolve() on list ... DONE
[01:29:10.310] A MultisessionFuture was resolved (and resolved itself)
- w/ exception ...
[01:29:10.310] getGlobalsAndPackages() ...
[01:29:10.310] Searching for globals...
[01:29:10.311] - globals found: [2] 'list', 'stop'
[01:29:10.311] Searching for globals ... DONE
[01:29:10.312] Resolving globals: FALSE
[01:29:10.312] 
[01:29:10.312] 
[01:29:10.312] getGlobalsAndPackages() ... DONE
[01:29:10.313] run() for 'Future' ...
[01:29:10.313] - state: 'created'
[01:29:10.313] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:10.328] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:10.328] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:10.328]   - Field: 'node'
[01:29:10.329]   - Field: 'label'
[01:29:10.329]   - Field: 'local'
[01:29:10.329]   - Field: 'owner'
[01:29:10.329]   - Field: 'envir'
[01:29:10.329]   - Field: 'workers'
[01:29:10.330]   - Field: 'packages'
[01:29:10.330]   - Field: 'gc'
[01:29:10.330]   - Field: 'conditions'
[01:29:10.330]   - Field: 'persistent'
[01:29:10.330]   - Field: 'expr'
[01:29:10.330]   - Field: 'uuid'
[01:29:10.331]   - Field: 'seed'
[01:29:10.331]   - Field: 'version'
[01:29:10.331]   - Field: 'result'
[01:29:10.331]   - Field: 'asynchronous'
[01:29:10.331]   - Field: 'calls'
[01:29:10.331]   - Field: 'globals'
[01:29:10.332]   - Field: 'stdout'
[01:29:10.332]   - Field: 'earlySignal'
[01:29:10.332]   - Field: 'lazy'
[01:29:10.332]   - Field: 'state'
[01:29:10.332] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:10.333] - Launch lazy future ...
[01:29:10.333] Packages needed by the future expression (n = 0): <none>
[01:29:10.333] Packages needed by future strategies (n = 0): <none>
[01:29:10.334] {
[01:29:10.334]     {
[01:29:10.334]         {
[01:29:10.334]             ...future.startTime <- base::Sys.time()
[01:29:10.334]             {
[01:29:10.334]                 {
[01:29:10.334]                   {
[01:29:10.334]                     {
[01:29:10.334]                       base::local({
[01:29:10.334]                         has_future <- base::requireNamespace("future", 
[01:29:10.334]                           quietly = TRUE)
[01:29:10.334]                         if (has_future) {
[01:29:10.334]                           ns <- base::getNamespace("future")
[01:29:10.334]                           version <- ns[[".package"]][["version"]]
[01:29:10.334]                           if (is.null(version)) 
[01:29:10.334]                             version <- utils::packageVersion("future")
[01:29:10.334]                         }
[01:29:10.334]                         else {
[01:29:10.334]                           version <- NULL
[01:29:10.334]                         }
[01:29:10.334]                         if (!has_future || version < "1.8.0") {
[01:29:10.334]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:10.334]                             "", base::R.version$version.string), 
[01:29:10.334]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:10.334]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:10.334]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:10.334]                               "release", "version")], collapse = " "), 
[01:29:10.334]                             hostname = base::Sys.info()[["nodename"]])
[01:29:10.334]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:10.334]                             info)
[01:29:10.334]                           info <- base::paste(info, collapse = "; ")
[01:29:10.334]                           if (!has_future) {
[01:29:10.334]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:10.334]                               info)
[01:29:10.334]                           }
[01:29:10.334]                           else {
[01:29:10.334]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:10.334]                               info, version)
[01:29:10.334]                           }
[01:29:10.334]                           base::stop(msg)
[01:29:10.334]                         }
[01:29:10.334]                       })
[01:29:10.334]                     }
[01:29:10.334]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:10.334]                     base::options(mc.cores = 1L)
[01:29:10.334]                   }
[01:29:10.334]                   options(future.plan = NULL)
[01:29:10.334]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:10.334]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:10.334]                 }
[01:29:10.334]                 ...future.workdir <- getwd()
[01:29:10.334]             }
[01:29:10.334]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:10.334]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:10.334]         }
[01:29:10.334]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:10.334]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:10.334]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:10.334]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:10.334]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:10.334]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:10.334]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:10.334]             base::names(...future.oldOptions))
[01:29:10.334]     }
[01:29:10.334]     if (FALSE) {
[01:29:10.334]     }
[01:29:10.334]     else {
[01:29:10.334]         if (TRUE) {
[01:29:10.334]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:10.334]                 open = "w")
[01:29:10.334]         }
[01:29:10.334]         else {
[01:29:10.334]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:10.334]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:10.334]         }
[01:29:10.334]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:10.334]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:10.334]             base::sink(type = "output", split = FALSE)
[01:29:10.334]             base::close(...future.stdout)
[01:29:10.334]         }, add = TRUE)
[01:29:10.334]     }
[01:29:10.334]     ...future.frame <- base::sys.nframe()
[01:29:10.334]     ...future.conditions <- base::list()
[01:29:10.334]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:10.334]     if (FALSE) {
[01:29:10.334]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:10.334]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:10.334]     }
[01:29:10.334]     ...future.result <- base::tryCatch({
[01:29:10.334]         base::withCallingHandlers({
[01:29:10.334]             ...future.value <- base::withVisible(base::local({
[01:29:10.334]                 ...future.makeSendCondition <- base::local({
[01:29:10.334]                   sendCondition <- NULL
[01:29:10.334]                   function(frame = 1L) {
[01:29:10.334]                     if (is.function(sendCondition)) 
[01:29:10.334]                       return(sendCondition)
[01:29:10.334]                     ns <- getNamespace("parallel")
[01:29:10.334]                     if (exists("sendData", mode = "function", 
[01:29:10.334]                       envir = ns)) {
[01:29:10.334]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:10.334]                         envir = ns)
[01:29:10.334]                       envir <- sys.frame(frame)
[01:29:10.334]                       master <- NULL
[01:29:10.334]                       while (!identical(envir, .GlobalEnv) && 
[01:29:10.334]                         !identical(envir, emptyenv())) {
[01:29:10.334]                         if (exists("master", mode = "list", envir = envir, 
[01:29:10.334]                           inherits = FALSE)) {
[01:29:10.334]                           master <- get("master", mode = "list", 
[01:29:10.334]                             envir = envir, inherits = FALSE)
[01:29:10.334]                           if (inherits(master, c("SOCKnode", 
[01:29:10.334]                             "SOCK0node"))) {
[01:29:10.334]                             sendCondition <<- function(cond) {
[01:29:10.334]                               data <- list(type = "VALUE", value = cond, 
[01:29:10.334]                                 success = TRUE)
[01:29:10.334]                               parallel_sendData(master, data)
[01:29:10.334]                             }
[01:29:10.334]                             return(sendCondition)
[01:29:10.334]                           }
[01:29:10.334]                         }
[01:29:10.334]                         frame <- frame + 1L
[01:29:10.334]                         envir <- sys.frame(frame)
[01:29:10.334]                       }
[01:29:10.334]                     }
[01:29:10.334]                     sendCondition <<- function(cond) NULL
[01:29:10.334]                   }
[01:29:10.334]                 })
[01:29:10.334]                 withCallingHandlers({
[01:29:10.334]                   list(a = 1, b = 42L, c = stop("Nah!"))
[01:29:10.334]                 }, immediateCondition = function(cond) {
[01:29:10.334]                   sendCondition <- ...future.makeSendCondition()
[01:29:10.334]                   sendCondition(cond)
[01:29:10.334]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:10.334]                   {
[01:29:10.334]                     inherits <- base::inherits
[01:29:10.334]                     invokeRestart <- base::invokeRestart
[01:29:10.334]                     is.null <- base::is.null
[01:29:10.334]                     muffled <- FALSE
[01:29:10.334]                     if (inherits(cond, "message")) {
[01:29:10.334]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:10.334]                       if (muffled) 
[01:29:10.334]                         invokeRestart("muffleMessage")
[01:29:10.334]                     }
[01:29:10.334]                     else if (inherits(cond, "warning")) {
[01:29:10.334]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:10.334]                       if (muffled) 
[01:29:10.334]                         invokeRestart("muffleWarning")
[01:29:10.334]                     }
[01:29:10.334]                     else if (inherits(cond, "condition")) {
[01:29:10.334]                       if (!is.null(pattern)) {
[01:29:10.334]                         computeRestarts <- base::computeRestarts
[01:29:10.334]                         grepl <- base::grepl
[01:29:10.334]                         restarts <- computeRestarts(cond)
[01:29:10.334]                         for (restart in restarts) {
[01:29:10.334]                           name <- restart$name
[01:29:10.334]                           if (is.null(name)) 
[01:29:10.334]                             next
[01:29:10.334]                           if (!grepl(pattern, name)) 
[01:29:10.334]                             next
[01:29:10.334]                           invokeRestart(restart)
[01:29:10.334]                           muffled <- TRUE
[01:29:10.334]                           break
[01:29:10.334]                         }
[01:29:10.334]                       }
[01:29:10.334]                     }
[01:29:10.334]                     invisible(muffled)
[01:29:10.334]                   }
[01:29:10.334]                   muffleCondition(cond)
[01:29:10.334]                 })
[01:29:10.334]             }))
[01:29:10.334]             future::FutureResult(value = ...future.value$value, 
[01:29:10.334]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:10.334]                   ...future.rng), globalenv = if (FALSE) 
[01:29:10.334]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:10.334]                     ...future.globalenv.names))
[01:29:10.334]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:10.334]         }, condition = base::local({
[01:29:10.334]             c <- base::c
[01:29:10.334]             inherits <- base::inherits
[01:29:10.334]             invokeRestart <- base::invokeRestart
[01:29:10.334]             length <- base::length
[01:29:10.334]             list <- base::list
[01:29:10.334]             seq.int <- base::seq.int
[01:29:10.334]             signalCondition <- base::signalCondition
[01:29:10.334]             sys.calls <- base::sys.calls
[01:29:10.334]             `[[` <- base::`[[`
[01:29:10.334]             `+` <- base::`+`
[01:29:10.334]             `<<-` <- base::`<<-`
[01:29:10.334]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:10.334]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:10.334]                   3L)]
[01:29:10.334]             }
[01:29:10.334]             function(cond) {
[01:29:10.334]                 is_error <- inherits(cond, "error")
[01:29:10.334]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:10.334]                   NULL)
[01:29:10.334]                 if (is_error) {
[01:29:10.334]                   sessionInformation <- function() {
[01:29:10.334]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:10.334]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:10.334]                       search = base::search(), system = base::Sys.info())
[01:29:10.334]                   }
[01:29:10.334]                   ...future.conditions[[length(...future.conditions) + 
[01:29:10.334]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:10.334]                     cond$call), session = sessionInformation(), 
[01:29:10.334]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:10.334]                   signalCondition(cond)
[01:29:10.334]                 }
[01:29:10.334]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:10.334]                 "immediateCondition"))) {
[01:29:10.334]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:10.334]                   ...future.conditions[[length(...future.conditions) + 
[01:29:10.334]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:10.334]                   if (TRUE && !signal) {
[01:29:10.334]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:10.334]                     {
[01:29:10.334]                       inherits <- base::inherits
[01:29:10.334]                       invokeRestart <- base::invokeRestart
[01:29:10.334]                       is.null <- base::is.null
[01:29:10.334]                       muffled <- FALSE
[01:29:10.334]                       if (inherits(cond, "message")) {
[01:29:10.334]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:10.334]                         if (muffled) 
[01:29:10.334]                           invokeRestart("muffleMessage")
[01:29:10.334]                       }
[01:29:10.334]                       else if (inherits(cond, "warning")) {
[01:29:10.334]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:10.334]                         if (muffled) 
[01:29:10.334]                           invokeRestart("muffleWarning")
[01:29:10.334]                       }
[01:29:10.334]                       else if (inherits(cond, "condition")) {
[01:29:10.334]                         if (!is.null(pattern)) {
[01:29:10.334]                           computeRestarts <- base::computeRestarts
[01:29:10.334]                           grepl <- base::grepl
[01:29:10.334]                           restarts <- computeRestarts(cond)
[01:29:10.334]                           for (restart in restarts) {
[01:29:10.334]                             name <- restart$name
[01:29:10.334]                             if (is.null(name)) 
[01:29:10.334]                               next
[01:29:10.334]                             if (!grepl(pattern, name)) 
[01:29:10.334]                               next
[01:29:10.334]                             invokeRestart(restart)
[01:29:10.334]                             muffled <- TRUE
[01:29:10.334]                             break
[01:29:10.334]                           }
[01:29:10.334]                         }
[01:29:10.334]                       }
[01:29:10.334]                       invisible(muffled)
[01:29:10.334]                     }
[01:29:10.334]                     muffleCondition(cond, pattern = "^muffle")
[01:29:10.334]                   }
[01:29:10.334]                 }
[01:29:10.334]                 else {
[01:29:10.334]                   if (TRUE) {
[01:29:10.334]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:10.334]                     {
[01:29:10.334]                       inherits <- base::inherits
[01:29:10.334]                       invokeRestart <- base::invokeRestart
[01:29:10.334]                       is.null <- base::is.null
[01:29:10.334]                       muffled <- FALSE
[01:29:10.334]                       if (inherits(cond, "message")) {
[01:29:10.334]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:10.334]                         if (muffled) 
[01:29:10.334]                           invokeRestart("muffleMessage")
[01:29:10.334]                       }
[01:29:10.334]                       else if (inherits(cond, "warning")) {
[01:29:10.334]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:10.334]                         if (muffled) 
[01:29:10.334]                           invokeRestart("muffleWarning")
[01:29:10.334]                       }
[01:29:10.334]                       else if (inherits(cond, "condition")) {
[01:29:10.334]                         if (!is.null(pattern)) {
[01:29:10.334]                           computeRestarts <- base::computeRestarts
[01:29:10.334]                           grepl <- base::grepl
[01:29:10.334]                           restarts <- computeRestarts(cond)
[01:29:10.334]                           for (restart in restarts) {
[01:29:10.334]                             name <- restart$name
[01:29:10.334]                             if (is.null(name)) 
[01:29:10.334]                               next
[01:29:10.334]                             if (!grepl(pattern, name)) 
[01:29:10.334]                               next
[01:29:10.334]                             invokeRestart(restart)
[01:29:10.334]                             muffled <- TRUE
[01:29:10.334]                             break
[01:29:10.334]                           }
[01:29:10.334]                         }
[01:29:10.334]                       }
[01:29:10.334]                       invisible(muffled)
[01:29:10.334]                     }
[01:29:10.334]                     muffleCondition(cond, pattern = "^muffle")
[01:29:10.334]                   }
[01:29:10.334]                 }
[01:29:10.334]             }
[01:29:10.334]         }))
[01:29:10.334]     }, error = function(ex) {
[01:29:10.334]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:10.334]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:10.334]                 ...future.rng), started = ...future.startTime, 
[01:29:10.334]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:10.334]             version = "1.8"), class = "FutureResult")
[01:29:10.334]     }, finally = {
[01:29:10.334]         if (!identical(...future.workdir, getwd())) 
[01:29:10.334]             setwd(...future.workdir)
[01:29:10.334]         {
[01:29:10.334]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:10.334]                 ...future.oldOptions$nwarnings <- NULL
[01:29:10.334]             }
[01:29:10.334]             base::options(...future.oldOptions)
[01:29:10.334]             if (.Platform$OS.type == "windows") {
[01:29:10.334]                 old_names <- names(...future.oldEnvVars)
[01:29:10.334]                 envs <- base::Sys.getenv()
[01:29:10.334]                 names <- names(envs)
[01:29:10.334]                 common <- intersect(names, old_names)
[01:29:10.334]                 added <- setdiff(names, old_names)
[01:29:10.334]                 removed <- setdiff(old_names, names)
[01:29:10.334]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:10.334]                   envs[common]]
[01:29:10.334]                 NAMES <- toupper(changed)
[01:29:10.334]                 args <- list()
[01:29:10.334]                 for (kk in seq_along(NAMES)) {
[01:29:10.334]                   name <- changed[[kk]]
[01:29:10.334]                   NAME <- NAMES[[kk]]
[01:29:10.334]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:10.334]                     next
[01:29:10.334]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:10.334]                 }
[01:29:10.334]                 NAMES <- toupper(added)
[01:29:10.334]                 for (kk in seq_along(NAMES)) {
[01:29:10.334]                   name <- added[[kk]]
[01:29:10.334]                   NAME <- NAMES[[kk]]
[01:29:10.334]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:10.334]                     next
[01:29:10.334]                   args[[name]] <- ""
[01:29:10.334]                 }
[01:29:10.334]                 NAMES <- toupper(removed)
[01:29:10.334]                 for (kk in seq_along(NAMES)) {
[01:29:10.334]                   name <- removed[[kk]]
[01:29:10.334]                   NAME <- NAMES[[kk]]
[01:29:10.334]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:10.334]                     next
[01:29:10.334]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:10.334]                 }
[01:29:10.334]                 if (length(args) > 0) 
[01:29:10.334]                   base::do.call(base::Sys.setenv, args = args)
[01:29:10.334]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:10.334]             }
[01:29:10.334]             else {
[01:29:10.334]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:10.334]             }
[01:29:10.334]             {
[01:29:10.334]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:10.334]                   0L) {
[01:29:10.334]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:10.334]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:10.334]                   base::options(opts)
[01:29:10.334]                 }
[01:29:10.334]                 {
[01:29:10.334]                   {
[01:29:10.334]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:10.334]                     NULL
[01:29:10.334]                   }
[01:29:10.334]                   options(future.plan = NULL)
[01:29:10.334]                   if (is.na(NA_character_)) 
[01:29:10.334]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:10.334]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:10.334]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:10.334]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:10.334]                     envir = parent.frame()) 
[01:29:10.334]                   {
[01:29:10.334]                     if (is.function(workers)) 
[01:29:10.334]                       workers <- workers()
[01:29:10.334]                     workers <- structure(as.integer(workers), 
[01:29:10.334]                       class = class(workers))
[01:29:10.334]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:10.334]                       workers >= 1)
[01:29:10.334]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:10.334]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:10.334]                     }
[01:29:10.334]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:10.334]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:10.334]                       envir = envir)
[01:29:10.334]                     if (!future$lazy) 
[01:29:10.334]                       future <- run(future)
[01:29:10.334]                     invisible(future)
[01:29:10.334]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:10.334]                 }
[01:29:10.334]             }
[01:29:10.334]         }
[01:29:10.334]     })
[01:29:10.334]     if (TRUE) {
[01:29:10.334]         base::sink(type = "output", split = FALSE)
[01:29:10.334]         if (TRUE) {
[01:29:10.334]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:10.334]         }
[01:29:10.334]         else {
[01:29:10.334]             ...future.result["stdout"] <- base::list(NULL)
[01:29:10.334]         }
[01:29:10.334]         base::close(...future.stdout)
[01:29:10.334]         ...future.stdout <- NULL
[01:29:10.334]     }
[01:29:10.334]     ...future.result$conditions <- ...future.conditions
[01:29:10.334]     ...future.result$finished <- base::Sys.time()
[01:29:10.334]     ...future.result
[01:29:10.334] }
[01:29:10.340] MultisessionFuture started
[01:29:10.340] - Launch lazy future ... done
[01:29:10.340] run() for 'MultisessionFuture' ... done
[01:29:10.368] receiveMessageFromWorker() for ClusterFuture ...
[01:29:10.368] - Validating connection of MultisessionFuture
[01:29:10.369] - received message: FutureResult
[01:29:10.369] - Received FutureResult
[01:29:10.369] - Erased future from FutureRegistry
[01:29:10.369] result() for ClusterFuture ...
[01:29:10.370] - result already collected: FutureResult
[01:29:10.370] result() for ClusterFuture ... done
[01:29:10.370] signalConditions() ...
[01:29:10.370]  - include = 'immediateCondition'
[01:29:10.370]  - exclude = 
[01:29:10.370]  - resignal = FALSE
[01:29:10.371]  - Number of conditions: 1
[01:29:10.371] signalConditions() ... done
[01:29:10.371] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:10.371] A MultisessionFuture was resolved (and resolved itself)
[01:29:10.371] getGlobalsAndPackages() ...
[01:29:10.371] Searching for globals...
[01:29:10.372] - globals found: [2] 'list', 'stop'
[01:29:10.373] Searching for globals ... DONE
[01:29:10.373] Resolving globals: FALSE
[01:29:10.373] 
[01:29:10.373] 
[01:29:10.373] getGlobalsAndPackages() ... DONE
[01:29:10.374] run() for 'Future' ...
[01:29:10.374] - state: 'created'
[01:29:10.374] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:10.389] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:10.390] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:10.390]   - Field: 'node'
[01:29:10.390]   - Field: 'label'
[01:29:10.390]   - Field: 'local'
[01:29:10.390]   - Field: 'owner'
[01:29:10.390]   - Field: 'envir'
[01:29:10.391]   - Field: 'workers'
[01:29:10.391]   - Field: 'packages'
[01:29:10.391]   - Field: 'gc'
[01:29:10.391]   - Field: 'conditions'
[01:29:10.391]   - Field: 'persistent'
[01:29:10.392]   - Field: 'expr'
[01:29:10.392]   - Field: 'uuid'
[01:29:10.392]   - Field: 'seed'
[01:29:10.392]   - Field: 'version'
[01:29:10.392]   - Field: 'result'
[01:29:10.392]   - Field: 'asynchronous'
[01:29:10.393]   - Field: 'calls'
[01:29:10.393]   - Field: 'globals'
[01:29:10.393]   - Field: 'stdout'
[01:29:10.393]   - Field: 'earlySignal'
[01:29:10.393]   - Field: 'lazy'
[01:29:10.394]   - Field: 'state'
[01:29:10.394] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:10.394] - Launch lazy future ...
[01:29:10.394] Packages needed by the future expression (n = 0): <none>
[01:29:10.394] Packages needed by future strategies (n = 0): <none>
[01:29:10.395] {
[01:29:10.395]     {
[01:29:10.395]         {
[01:29:10.395]             ...future.startTime <- base::Sys.time()
[01:29:10.395]             {
[01:29:10.395]                 {
[01:29:10.395]                   {
[01:29:10.395]                     {
[01:29:10.395]                       base::local({
[01:29:10.395]                         has_future <- base::requireNamespace("future", 
[01:29:10.395]                           quietly = TRUE)
[01:29:10.395]                         if (has_future) {
[01:29:10.395]                           ns <- base::getNamespace("future")
[01:29:10.395]                           version <- ns[[".package"]][["version"]]
[01:29:10.395]                           if (is.null(version)) 
[01:29:10.395]                             version <- utils::packageVersion("future")
[01:29:10.395]                         }
[01:29:10.395]                         else {
[01:29:10.395]                           version <- NULL
[01:29:10.395]                         }
[01:29:10.395]                         if (!has_future || version < "1.8.0") {
[01:29:10.395]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:10.395]                             "", base::R.version$version.string), 
[01:29:10.395]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:10.395]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:10.395]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:10.395]                               "release", "version")], collapse = " "), 
[01:29:10.395]                             hostname = base::Sys.info()[["nodename"]])
[01:29:10.395]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:10.395]                             info)
[01:29:10.395]                           info <- base::paste(info, collapse = "; ")
[01:29:10.395]                           if (!has_future) {
[01:29:10.395]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:10.395]                               info)
[01:29:10.395]                           }
[01:29:10.395]                           else {
[01:29:10.395]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:10.395]                               info, version)
[01:29:10.395]                           }
[01:29:10.395]                           base::stop(msg)
[01:29:10.395]                         }
[01:29:10.395]                       })
[01:29:10.395]                     }
[01:29:10.395]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:10.395]                     base::options(mc.cores = 1L)
[01:29:10.395]                   }
[01:29:10.395]                   options(future.plan = NULL)
[01:29:10.395]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:10.395]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:10.395]                 }
[01:29:10.395]                 ...future.workdir <- getwd()
[01:29:10.395]             }
[01:29:10.395]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:10.395]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:10.395]         }
[01:29:10.395]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:10.395]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:10.395]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:10.395]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:10.395]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:10.395]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:10.395]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:10.395]             base::names(...future.oldOptions))
[01:29:10.395]     }
[01:29:10.395]     if (FALSE) {
[01:29:10.395]     }
[01:29:10.395]     else {
[01:29:10.395]         if (TRUE) {
[01:29:10.395]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:10.395]                 open = "w")
[01:29:10.395]         }
[01:29:10.395]         else {
[01:29:10.395]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:10.395]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:10.395]         }
[01:29:10.395]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:10.395]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:10.395]             base::sink(type = "output", split = FALSE)
[01:29:10.395]             base::close(...future.stdout)
[01:29:10.395]         }, add = TRUE)
[01:29:10.395]     }
[01:29:10.395]     ...future.frame <- base::sys.nframe()
[01:29:10.395]     ...future.conditions <- base::list()
[01:29:10.395]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:10.395]     if (FALSE) {
[01:29:10.395]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:10.395]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:10.395]     }
[01:29:10.395]     ...future.result <- base::tryCatch({
[01:29:10.395]         base::withCallingHandlers({
[01:29:10.395]             ...future.value <- base::withVisible(base::local({
[01:29:10.395]                 ...future.makeSendCondition <- base::local({
[01:29:10.395]                   sendCondition <- NULL
[01:29:10.395]                   function(frame = 1L) {
[01:29:10.395]                     if (is.function(sendCondition)) 
[01:29:10.395]                       return(sendCondition)
[01:29:10.395]                     ns <- getNamespace("parallel")
[01:29:10.395]                     if (exists("sendData", mode = "function", 
[01:29:10.395]                       envir = ns)) {
[01:29:10.395]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:10.395]                         envir = ns)
[01:29:10.395]                       envir <- sys.frame(frame)
[01:29:10.395]                       master <- NULL
[01:29:10.395]                       while (!identical(envir, .GlobalEnv) && 
[01:29:10.395]                         !identical(envir, emptyenv())) {
[01:29:10.395]                         if (exists("master", mode = "list", envir = envir, 
[01:29:10.395]                           inherits = FALSE)) {
[01:29:10.395]                           master <- get("master", mode = "list", 
[01:29:10.395]                             envir = envir, inherits = FALSE)
[01:29:10.395]                           if (inherits(master, c("SOCKnode", 
[01:29:10.395]                             "SOCK0node"))) {
[01:29:10.395]                             sendCondition <<- function(cond) {
[01:29:10.395]                               data <- list(type = "VALUE", value = cond, 
[01:29:10.395]                                 success = TRUE)
[01:29:10.395]                               parallel_sendData(master, data)
[01:29:10.395]                             }
[01:29:10.395]                             return(sendCondition)
[01:29:10.395]                           }
[01:29:10.395]                         }
[01:29:10.395]                         frame <- frame + 1L
[01:29:10.395]                         envir <- sys.frame(frame)
[01:29:10.395]                       }
[01:29:10.395]                     }
[01:29:10.395]                     sendCondition <<- function(cond) NULL
[01:29:10.395]                   }
[01:29:10.395]                 })
[01:29:10.395]                 withCallingHandlers({
[01:29:10.395]                   list(a = 1, b = 42L, c = stop("Nah!"))
[01:29:10.395]                 }, immediateCondition = function(cond) {
[01:29:10.395]                   sendCondition <- ...future.makeSendCondition()
[01:29:10.395]                   sendCondition(cond)
[01:29:10.395]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:10.395]                   {
[01:29:10.395]                     inherits <- base::inherits
[01:29:10.395]                     invokeRestart <- base::invokeRestart
[01:29:10.395]                     is.null <- base::is.null
[01:29:10.395]                     muffled <- FALSE
[01:29:10.395]                     if (inherits(cond, "message")) {
[01:29:10.395]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:10.395]                       if (muffled) 
[01:29:10.395]                         invokeRestart("muffleMessage")
[01:29:10.395]                     }
[01:29:10.395]                     else if (inherits(cond, "warning")) {
[01:29:10.395]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:10.395]                       if (muffled) 
[01:29:10.395]                         invokeRestart("muffleWarning")
[01:29:10.395]                     }
[01:29:10.395]                     else if (inherits(cond, "condition")) {
[01:29:10.395]                       if (!is.null(pattern)) {
[01:29:10.395]                         computeRestarts <- base::computeRestarts
[01:29:10.395]                         grepl <- base::grepl
[01:29:10.395]                         restarts <- computeRestarts(cond)
[01:29:10.395]                         for (restart in restarts) {
[01:29:10.395]                           name <- restart$name
[01:29:10.395]                           if (is.null(name)) 
[01:29:10.395]                             next
[01:29:10.395]                           if (!grepl(pattern, name)) 
[01:29:10.395]                             next
[01:29:10.395]                           invokeRestart(restart)
[01:29:10.395]                           muffled <- TRUE
[01:29:10.395]                           break
[01:29:10.395]                         }
[01:29:10.395]                       }
[01:29:10.395]                     }
[01:29:10.395]                     invisible(muffled)
[01:29:10.395]                   }
[01:29:10.395]                   muffleCondition(cond)
[01:29:10.395]                 })
[01:29:10.395]             }))
[01:29:10.395]             future::FutureResult(value = ...future.value$value, 
[01:29:10.395]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:10.395]                   ...future.rng), globalenv = if (FALSE) 
[01:29:10.395]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:10.395]                     ...future.globalenv.names))
[01:29:10.395]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:10.395]         }, condition = base::local({
[01:29:10.395]             c <- base::c
[01:29:10.395]             inherits <- base::inherits
[01:29:10.395]             invokeRestart <- base::invokeRestart
[01:29:10.395]             length <- base::length
[01:29:10.395]             list <- base::list
[01:29:10.395]             seq.int <- base::seq.int
[01:29:10.395]             signalCondition <- base::signalCondition
[01:29:10.395]             sys.calls <- base::sys.calls
[01:29:10.395]             `[[` <- base::`[[`
[01:29:10.395]             `+` <- base::`+`
[01:29:10.395]             `<<-` <- base::`<<-`
[01:29:10.395]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:10.395]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:10.395]                   3L)]
[01:29:10.395]             }
[01:29:10.395]             function(cond) {
[01:29:10.395]                 is_error <- inherits(cond, "error")
[01:29:10.395]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:10.395]                   NULL)
[01:29:10.395]                 if (is_error) {
[01:29:10.395]                   sessionInformation <- function() {
[01:29:10.395]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:10.395]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:10.395]                       search = base::search(), system = base::Sys.info())
[01:29:10.395]                   }
[01:29:10.395]                   ...future.conditions[[length(...future.conditions) + 
[01:29:10.395]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:10.395]                     cond$call), session = sessionInformation(), 
[01:29:10.395]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:10.395]                   signalCondition(cond)
[01:29:10.395]                 }
[01:29:10.395]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:10.395]                 "immediateCondition"))) {
[01:29:10.395]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:10.395]                   ...future.conditions[[length(...future.conditions) + 
[01:29:10.395]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:10.395]                   if (TRUE && !signal) {
[01:29:10.395]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:10.395]                     {
[01:29:10.395]                       inherits <- base::inherits
[01:29:10.395]                       invokeRestart <- base::invokeRestart
[01:29:10.395]                       is.null <- base::is.null
[01:29:10.395]                       muffled <- FALSE
[01:29:10.395]                       if (inherits(cond, "message")) {
[01:29:10.395]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:10.395]                         if (muffled) 
[01:29:10.395]                           invokeRestart("muffleMessage")
[01:29:10.395]                       }
[01:29:10.395]                       else if (inherits(cond, "warning")) {
[01:29:10.395]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:10.395]                         if (muffled) 
[01:29:10.395]                           invokeRestart("muffleWarning")
[01:29:10.395]                       }
[01:29:10.395]                       else if (inherits(cond, "condition")) {
[01:29:10.395]                         if (!is.null(pattern)) {
[01:29:10.395]                           computeRestarts <- base::computeRestarts
[01:29:10.395]                           grepl <- base::grepl
[01:29:10.395]                           restarts <- computeRestarts(cond)
[01:29:10.395]                           for (restart in restarts) {
[01:29:10.395]                             name <- restart$name
[01:29:10.395]                             if (is.null(name)) 
[01:29:10.395]                               next
[01:29:10.395]                             if (!grepl(pattern, name)) 
[01:29:10.395]                               next
[01:29:10.395]                             invokeRestart(restart)
[01:29:10.395]                             muffled <- TRUE
[01:29:10.395]                             break
[01:29:10.395]                           }
[01:29:10.395]                         }
[01:29:10.395]                       }
[01:29:10.395]                       invisible(muffled)
[01:29:10.395]                     }
[01:29:10.395]                     muffleCondition(cond, pattern = "^muffle")
[01:29:10.395]                   }
[01:29:10.395]                 }
[01:29:10.395]                 else {
[01:29:10.395]                   if (TRUE) {
[01:29:10.395]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:10.395]                     {
[01:29:10.395]                       inherits <- base::inherits
[01:29:10.395]                       invokeRestart <- base::invokeRestart
[01:29:10.395]                       is.null <- base::is.null
[01:29:10.395]                       muffled <- FALSE
[01:29:10.395]                       if (inherits(cond, "message")) {
[01:29:10.395]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:10.395]                         if (muffled) 
[01:29:10.395]                           invokeRestart("muffleMessage")
[01:29:10.395]                       }
[01:29:10.395]                       else if (inherits(cond, "warning")) {
[01:29:10.395]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:10.395]                         if (muffled) 
[01:29:10.395]                           invokeRestart("muffleWarning")
[01:29:10.395]                       }
[01:29:10.395]                       else if (inherits(cond, "condition")) {
[01:29:10.395]                         if (!is.null(pattern)) {
[01:29:10.395]                           computeRestarts <- base::computeRestarts
[01:29:10.395]                           grepl <- base::grepl
[01:29:10.395]                           restarts <- computeRestarts(cond)
[01:29:10.395]                           for (restart in restarts) {
[01:29:10.395]                             name <- restart$name
[01:29:10.395]                             if (is.null(name)) 
[01:29:10.395]                               next
[01:29:10.395]                             if (!grepl(pattern, name)) 
[01:29:10.395]                               next
[01:29:10.395]                             invokeRestart(restart)
[01:29:10.395]                             muffled <- TRUE
[01:29:10.395]                             break
[01:29:10.395]                           }
[01:29:10.395]                         }
[01:29:10.395]                       }
[01:29:10.395]                       invisible(muffled)
[01:29:10.395]                     }
[01:29:10.395]                     muffleCondition(cond, pattern = "^muffle")
[01:29:10.395]                   }
[01:29:10.395]                 }
[01:29:10.395]             }
[01:29:10.395]         }))
[01:29:10.395]     }, error = function(ex) {
[01:29:10.395]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:10.395]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:10.395]                 ...future.rng), started = ...future.startTime, 
[01:29:10.395]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:10.395]             version = "1.8"), class = "FutureResult")
[01:29:10.395]     }, finally = {
[01:29:10.395]         if (!identical(...future.workdir, getwd())) 
[01:29:10.395]             setwd(...future.workdir)
[01:29:10.395]         {
[01:29:10.395]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:10.395]                 ...future.oldOptions$nwarnings <- NULL
[01:29:10.395]             }
[01:29:10.395]             base::options(...future.oldOptions)
[01:29:10.395]             if (.Platform$OS.type == "windows") {
[01:29:10.395]                 old_names <- names(...future.oldEnvVars)
[01:29:10.395]                 envs <- base::Sys.getenv()
[01:29:10.395]                 names <- names(envs)
[01:29:10.395]                 common <- intersect(names, old_names)
[01:29:10.395]                 added <- setdiff(names, old_names)
[01:29:10.395]                 removed <- setdiff(old_names, names)
[01:29:10.395]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:10.395]                   envs[common]]
[01:29:10.395]                 NAMES <- toupper(changed)
[01:29:10.395]                 args <- list()
[01:29:10.395]                 for (kk in seq_along(NAMES)) {
[01:29:10.395]                   name <- changed[[kk]]
[01:29:10.395]                   NAME <- NAMES[[kk]]
[01:29:10.395]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:10.395]                     next
[01:29:10.395]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:10.395]                 }
[01:29:10.395]                 NAMES <- toupper(added)
[01:29:10.395]                 for (kk in seq_along(NAMES)) {
[01:29:10.395]                   name <- added[[kk]]
[01:29:10.395]                   NAME <- NAMES[[kk]]
[01:29:10.395]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:10.395]                     next
[01:29:10.395]                   args[[name]] <- ""
[01:29:10.395]                 }
[01:29:10.395]                 NAMES <- toupper(removed)
[01:29:10.395]                 for (kk in seq_along(NAMES)) {
[01:29:10.395]                   name <- removed[[kk]]
[01:29:10.395]                   NAME <- NAMES[[kk]]
[01:29:10.395]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:10.395]                     next
[01:29:10.395]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:10.395]                 }
[01:29:10.395]                 if (length(args) > 0) 
[01:29:10.395]                   base::do.call(base::Sys.setenv, args = args)
[01:29:10.395]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:10.395]             }
[01:29:10.395]             else {
[01:29:10.395]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:10.395]             }
[01:29:10.395]             {
[01:29:10.395]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:10.395]                   0L) {
[01:29:10.395]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:10.395]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:10.395]                   base::options(opts)
[01:29:10.395]                 }
[01:29:10.395]                 {
[01:29:10.395]                   {
[01:29:10.395]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:10.395]                     NULL
[01:29:10.395]                   }
[01:29:10.395]                   options(future.plan = NULL)
[01:29:10.395]                   if (is.na(NA_character_)) 
[01:29:10.395]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:10.395]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:10.395]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:10.395]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:10.395]                     envir = parent.frame()) 
[01:29:10.395]                   {
[01:29:10.395]                     if (is.function(workers)) 
[01:29:10.395]                       workers <- workers()
[01:29:10.395]                     workers <- structure(as.integer(workers), 
[01:29:10.395]                       class = class(workers))
[01:29:10.395]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:10.395]                       workers >= 1)
[01:29:10.395]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:10.395]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:10.395]                     }
[01:29:10.395]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:10.395]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:10.395]                       envir = envir)
[01:29:10.395]                     if (!future$lazy) 
[01:29:10.395]                       future <- run(future)
[01:29:10.395]                     invisible(future)
[01:29:10.395]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:10.395]                 }
[01:29:10.395]             }
[01:29:10.395]         }
[01:29:10.395]     })
[01:29:10.395]     if (TRUE) {
[01:29:10.395]         base::sink(type = "output", split = FALSE)
[01:29:10.395]         if (TRUE) {
[01:29:10.395]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:10.395]         }
[01:29:10.395]         else {
[01:29:10.395]             ...future.result["stdout"] <- base::list(NULL)
[01:29:10.395]         }
[01:29:10.395]         base::close(...future.stdout)
[01:29:10.395]         ...future.stdout <- NULL
[01:29:10.395]     }
[01:29:10.395]     ...future.result$conditions <- ...future.conditions
[01:29:10.395]     ...future.result$finished <- base::Sys.time()
[01:29:10.395]     ...future.result
[01:29:10.395] }
[01:29:10.402] MultisessionFuture started
[01:29:10.402] - Launch lazy future ... done
[01:29:10.402] run() for 'MultisessionFuture' ... done
[01:29:10.427] receiveMessageFromWorker() for ClusterFuture ...
[01:29:10.428] - Validating connection of MultisessionFuture
[01:29:10.428] - received message: FutureResult
[01:29:10.428] - Received FutureResult
[01:29:10.429] - Erased future from FutureRegistry
[01:29:10.429] result() for ClusterFuture ...
[01:29:10.429] - result already collected: FutureResult
[01:29:10.429] result() for ClusterFuture ... done
[01:29:10.429] signalConditions() ...
[01:29:10.429]  - include = 'immediateCondition'
[01:29:10.430]  - exclude = 
[01:29:10.430]  - resignal = FALSE
[01:29:10.430]  - Number of conditions: 1
[01:29:10.430] signalConditions() ... done
[01:29:10.430] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:10.431] A MultisessionFuture was resolved (and resolved itself)
- result = TRUE, recursive = 2 ... DONE
- result = TRUE, recursive = Inf ...
[01:29:10.431] getGlobalsAndPackages() ...
[01:29:10.431] Searching for globals...
[01:29:10.433] - globals found: [3] '{', 'Sys.sleep', 'list'
[01:29:10.433] Searching for globals ... DONE
[01:29:10.433] Resolving globals: FALSE
[01:29:10.433] 
[01:29:10.434] 
[01:29:10.434] getGlobalsAndPackages() ... DONE
[01:29:10.434] run() for 'Future' ...
[01:29:10.434] - state: 'created'
[01:29:10.434] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:10.449] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:10.450] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:10.450]   - Field: 'node'
[01:29:10.450]   - Field: 'label'
[01:29:10.450]   - Field: 'local'
[01:29:10.450]   - Field: 'owner'
[01:29:10.451]   - Field: 'envir'
[01:29:10.451]   - Field: 'workers'
[01:29:10.451]   - Field: 'packages'
[01:29:10.451]   - Field: 'gc'
[01:29:10.451]   - Field: 'conditions'
[01:29:10.451]   - Field: 'persistent'
[01:29:10.452]   - Field: 'expr'
[01:29:10.452]   - Field: 'uuid'
[01:29:10.452]   - Field: 'seed'
[01:29:10.452]   - Field: 'version'
[01:29:10.452]   - Field: 'result'
[01:29:10.452]   - Field: 'asynchronous'
[01:29:10.453]   - Field: 'calls'
[01:29:10.453]   - Field: 'globals'
[01:29:10.453]   - Field: 'stdout'
[01:29:10.453]   - Field: 'earlySignal'
[01:29:10.453]   - Field: 'lazy'
[01:29:10.454]   - Field: 'state'
[01:29:10.454] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:10.454] - Launch lazy future ...
[01:29:10.454] Packages needed by the future expression (n = 0): <none>
[01:29:10.454] Packages needed by future strategies (n = 0): <none>
[01:29:10.455] {
[01:29:10.455]     {
[01:29:10.455]         {
[01:29:10.455]             ...future.startTime <- base::Sys.time()
[01:29:10.455]             {
[01:29:10.455]                 {
[01:29:10.455]                   {
[01:29:10.455]                     {
[01:29:10.455]                       base::local({
[01:29:10.455]                         has_future <- base::requireNamespace("future", 
[01:29:10.455]                           quietly = TRUE)
[01:29:10.455]                         if (has_future) {
[01:29:10.455]                           ns <- base::getNamespace("future")
[01:29:10.455]                           version <- ns[[".package"]][["version"]]
[01:29:10.455]                           if (is.null(version)) 
[01:29:10.455]                             version <- utils::packageVersion("future")
[01:29:10.455]                         }
[01:29:10.455]                         else {
[01:29:10.455]                           version <- NULL
[01:29:10.455]                         }
[01:29:10.455]                         if (!has_future || version < "1.8.0") {
[01:29:10.455]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:10.455]                             "", base::R.version$version.string), 
[01:29:10.455]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:10.455]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:10.455]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:10.455]                               "release", "version")], collapse = " "), 
[01:29:10.455]                             hostname = base::Sys.info()[["nodename"]])
[01:29:10.455]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:10.455]                             info)
[01:29:10.455]                           info <- base::paste(info, collapse = "; ")
[01:29:10.455]                           if (!has_future) {
[01:29:10.455]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:10.455]                               info)
[01:29:10.455]                           }
[01:29:10.455]                           else {
[01:29:10.455]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:10.455]                               info, version)
[01:29:10.455]                           }
[01:29:10.455]                           base::stop(msg)
[01:29:10.455]                         }
[01:29:10.455]                       })
[01:29:10.455]                     }
[01:29:10.455]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:10.455]                     base::options(mc.cores = 1L)
[01:29:10.455]                   }
[01:29:10.455]                   options(future.plan = NULL)
[01:29:10.455]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:10.455]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:10.455]                 }
[01:29:10.455]                 ...future.workdir <- getwd()
[01:29:10.455]             }
[01:29:10.455]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:10.455]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:10.455]         }
[01:29:10.455]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:10.455]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:10.455]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:10.455]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:10.455]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:10.455]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:10.455]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:10.455]             base::names(...future.oldOptions))
[01:29:10.455]     }
[01:29:10.455]     if (FALSE) {
[01:29:10.455]     }
[01:29:10.455]     else {
[01:29:10.455]         if (TRUE) {
[01:29:10.455]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:10.455]                 open = "w")
[01:29:10.455]         }
[01:29:10.455]         else {
[01:29:10.455]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:10.455]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:10.455]         }
[01:29:10.455]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:10.455]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:10.455]             base::sink(type = "output", split = FALSE)
[01:29:10.455]             base::close(...future.stdout)
[01:29:10.455]         }, add = TRUE)
[01:29:10.455]     }
[01:29:10.455]     ...future.frame <- base::sys.nframe()
[01:29:10.455]     ...future.conditions <- base::list()
[01:29:10.455]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:10.455]     if (FALSE) {
[01:29:10.455]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:10.455]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:10.455]     }
[01:29:10.455]     ...future.result <- base::tryCatch({
[01:29:10.455]         base::withCallingHandlers({
[01:29:10.455]             ...future.value <- base::withVisible(base::local({
[01:29:10.455]                 ...future.makeSendCondition <- base::local({
[01:29:10.455]                   sendCondition <- NULL
[01:29:10.455]                   function(frame = 1L) {
[01:29:10.455]                     if (is.function(sendCondition)) 
[01:29:10.455]                       return(sendCondition)
[01:29:10.455]                     ns <- getNamespace("parallel")
[01:29:10.455]                     if (exists("sendData", mode = "function", 
[01:29:10.455]                       envir = ns)) {
[01:29:10.455]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:10.455]                         envir = ns)
[01:29:10.455]                       envir <- sys.frame(frame)
[01:29:10.455]                       master <- NULL
[01:29:10.455]                       while (!identical(envir, .GlobalEnv) && 
[01:29:10.455]                         !identical(envir, emptyenv())) {
[01:29:10.455]                         if (exists("master", mode = "list", envir = envir, 
[01:29:10.455]                           inherits = FALSE)) {
[01:29:10.455]                           master <- get("master", mode = "list", 
[01:29:10.455]                             envir = envir, inherits = FALSE)
[01:29:10.455]                           if (inherits(master, c("SOCKnode", 
[01:29:10.455]                             "SOCK0node"))) {
[01:29:10.455]                             sendCondition <<- function(cond) {
[01:29:10.455]                               data <- list(type = "VALUE", value = cond, 
[01:29:10.455]                                 success = TRUE)
[01:29:10.455]                               parallel_sendData(master, data)
[01:29:10.455]                             }
[01:29:10.455]                             return(sendCondition)
[01:29:10.455]                           }
[01:29:10.455]                         }
[01:29:10.455]                         frame <- frame + 1L
[01:29:10.455]                         envir <- sys.frame(frame)
[01:29:10.455]                       }
[01:29:10.455]                     }
[01:29:10.455]                     sendCondition <<- function(cond) NULL
[01:29:10.455]                   }
[01:29:10.455]                 })
[01:29:10.455]                 withCallingHandlers({
[01:29:10.455]                   {
[01:29:10.455]                     Sys.sleep(0.5)
[01:29:10.455]                     list(a = 1, b = 42L)
[01:29:10.455]                   }
[01:29:10.455]                 }, immediateCondition = function(cond) {
[01:29:10.455]                   sendCondition <- ...future.makeSendCondition()
[01:29:10.455]                   sendCondition(cond)
[01:29:10.455]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:10.455]                   {
[01:29:10.455]                     inherits <- base::inherits
[01:29:10.455]                     invokeRestart <- base::invokeRestart
[01:29:10.455]                     is.null <- base::is.null
[01:29:10.455]                     muffled <- FALSE
[01:29:10.455]                     if (inherits(cond, "message")) {
[01:29:10.455]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:10.455]                       if (muffled) 
[01:29:10.455]                         invokeRestart("muffleMessage")
[01:29:10.455]                     }
[01:29:10.455]                     else if (inherits(cond, "warning")) {
[01:29:10.455]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:10.455]                       if (muffled) 
[01:29:10.455]                         invokeRestart("muffleWarning")
[01:29:10.455]                     }
[01:29:10.455]                     else if (inherits(cond, "condition")) {
[01:29:10.455]                       if (!is.null(pattern)) {
[01:29:10.455]                         computeRestarts <- base::computeRestarts
[01:29:10.455]                         grepl <- base::grepl
[01:29:10.455]                         restarts <- computeRestarts(cond)
[01:29:10.455]                         for (restart in restarts) {
[01:29:10.455]                           name <- restart$name
[01:29:10.455]                           if (is.null(name)) 
[01:29:10.455]                             next
[01:29:10.455]                           if (!grepl(pattern, name)) 
[01:29:10.455]                             next
[01:29:10.455]                           invokeRestart(restart)
[01:29:10.455]                           muffled <- TRUE
[01:29:10.455]                           break
[01:29:10.455]                         }
[01:29:10.455]                       }
[01:29:10.455]                     }
[01:29:10.455]                     invisible(muffled)
[01:29:10.455]                   }
[01:29:10.455]                   muffleCondition(cond)
[01:29:10.455]                 })
[01:29:10.455]             }))
[01:29:10.455]             future::FutureResult(value = ...future.value$value, 
[01:29:10.455]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:10.455]                   ...future.rng), globalenv = if (FALSE) 
[01:29:10.455]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:10.455]                     ...future.globalenv.names))
[01:29:10.455]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:10.455]         }, condition = base::local({
[01:29:10.455]             c <- base::c
[01:29:10.455]             inherits <- base::inherits
[01:29:10.455]             invokeRestart <- base::invokeRestart
[01:29:10.455]             length <- base::length
[01:29:10.455]             list <- base::list
[01:29:10.455]             seq.int <- base::seq.int
[01:29:10.455]             signalCondition <- base::signalCondition
[01:29:10.455]             sys.calls <- base::sys.calls
[01:29:10.455]             `[[` <- base::`[[`
[01:29:10.455]             `+` <- base::`+`
[01:29:10.455]             `<<-` <- base::`<<-`
[01:29:10.455]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:10.455]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:10.455]                   3L)]
[01:29:10.455]             }
[01:29:10.455]             function(cond) {
[01:29:10.455]                 is_error <- inherits(cond, "error")
[01:29:10.455]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:10.455]                   NULL)
[01:29:10.455]                 if (is_error) {
[01:29:10.455]                   sessionInformation <- function() {
[01:29:10.455]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:10.455]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:10.455]                       search = base::search(), system = base::Sys.info())
[01:29:10.455]                   }
[01:29:10.455]                   ...future.conditions[[length(...future.conditions) + 
[01:29:10.455]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:10.455]                     cond$call), session = sessionInformation(), 
[01:29:10.455]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:10.455]                   signalCondition(cond)
[01:29:10.455]                 }
[01:29:10.455]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:10.455]                 "immediateCondition"))) {
[01:29:10.455]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:10.455]                   ...future.conditions[[length(...future.conditions) + 
[01:29:10.455]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:10.455]                   if (TRUE && !signal) {
[01:29:10.455]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:10.455]                     {
[01:29:10.455]                       inherits <- base::inherits
[01:29:10.455]                       invokeRestart <- base::invokeRestart
[01:29:10.455]                       is.null <- base::is.null
[01:29:10.455]                       muffled <- FALSE
[01:29:10.455]                       if (inherits(cond, "message")) {
[01:29:10.455]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:10.455]                         if (muffled) 
[01:29:10.455]                           invokeRestart("muffleMessage")
[01:29:10.455]                       }
[01:29:10.455]                       else if (inherits(cond, "warning")) {
[01:29:10.455]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:10.455]                         if (muffled) 
[01:29:10.455]                           invokeRestart("muffleWarning")
[01:29:10.455]                       }
[01:29:10.455]                       else if (inherits(cond, "condition")) {
[01:29:10.455]                         if (!is.null(pattern)) {
[01:29:10.455]                           computeRestarts <- base::computeRestarts
[01:29:10.455]                           grepl <- base::grepl
[01:29:10.455]                           restarts <- computeRestarts(cond)
[01:29:10.455]                           for (restart in restarts) {
[01:29:10.455]                             name <- restart$name
[01:29:10.455]                             if (is.null(name)) 
[01:29:10.455]                               next
[01:29:10.455]                             if (!grepl(pattern, name)) 
[01:29:10.455]                               next
[01:29:10.455]                             invokeRestart(restart)
[01:29:10.455]                             muffled <- TRUE
[01:29:10.455]                             break
[01:29:10.455]                           }
[01:29:10.455]                         }
[01:29:10.455]                       }
[01:29:10.455]                       invisible(muffled)
[01:29:10.455]                     }
[01:29:10.455]                     muffleCondition(cond, pattern = "^muffle")
[01:29:10.455]                   }
[01:29:10.455]                 }
[01:29:10.455]                 else {
[01:29:10.455]                   if (TRUE) {
[01:29:10.455]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:10.455]                     {
[01:29:10.455]                       inherits <- base::inherits
[01:29:10.455]                       invokeRestart <- base::invokeRestart
[01:29:10.455]                       is.null <- base::is.null
[01:29:10.455]                       muffled <- FALSE
[01:29:10.455]                       if (inherits(cond, "message")) {
[01:29:10.455]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:10.455]                         if (muffled) 
[01:29:10.455]                           invokeRestart("muffleMessage")
[01:29:10.455]                       }
[01:29:10.455]                       else if (inherits(cond, "warning")) {
[01:29:10.455]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:10.455]                         if (muffled) 
[01:29:10.455]                           invokeRestart("muffleWarning")
[01:29:10.455]                       }
[01:29:10.455]                       else if (inherits(cond, "condition")) {
[01:29:10.455]                         if (!is.null(pattern)) {
[01:29:10.455]                           computeRestarts <- base::computeRestarts
[01:29:10.455]                           grepl <- base::grepl
[01:29:10.455]                           restarts <- computeRestarts(cond)
[01:29:10.455]                           for (restart in restarts) {
[01:29:10.455]                             name <- restart$name
[01:29:10.455]                             if (is.null(name)) 
[01:29:10.455]                               next
[01:29:10.455]                             if (!grepl(pattern, name)) 
[01:29:10.455]                               next
[01:29:10.455]                             invokeRestart(restart)
[01:29:10.455]                             muffled <- TRUE
[01:29:10.455]                             break
[01:29:10.455]                           }
[01:29:10.455]                         }
[01:29:10.455]                       }
[01:29:10.455]                       invisible(muffled)
[01:29:10.455]                     }
[01:29:10.455]                     muffleCondition(cond, pattern = "^muffle")
[01:29:10.455]                   }
[01:29:10.455]                 }
[01:29:10.455]             }
[01:29:10.455]         }))
[01:29:10.455]     }, error = function(ex) {
[01:29:10.455]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:10.455]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:10.455]                 ...future.rng), started = ...future.startTime, 
[01:29:10.455]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:10.455]             version = "1.8"), class = "FutureResult")
[01:29:10.455]     }, finally = {
[01:29:10.455]         if (!identical(...future.workdir, getwd())) 
[01:29:10.455]             setwd(...future.workdir)
[01:29:10.455]         {
[01:29:10.455]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:10.455]                 ...future.oldOptions$nwarnings <- NULL
[01:29:10.455]             }
[01:29:10.455]             base::options(...future.oldOptions)
[01:29:10.455]             if (.Platform$OS.type == "windows") {
[01:29:10.455]                 old_names <- names(...future.oldEnvVars)
[01:29:10.455]                 envs <- base::Sys.getenv()
[01:29:10.455]                 names <- names(envs)
[01:29:10.455]                 common <- intersect(names, old_names)
[01:29:10.455]                 added <- setdiff(names, old_names)
[01:29:10.455]                 removed <- setdiff(old_names, names)
[01:29:10.455]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:10.455]                   envs[common]]
[01:29:10.455]                 NAMES <- toupper(changed)
[01:29:10.455]                 args <- list()
[01:29:10.455]                 for (kk in seq_along(NAMES)) {
[01:29:10.455]                   name <- changed[[kk]]
[01:29:10.455]                   NAME <- NAMES[[kk]]
[01:29:10.455]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:10.455]                     next
[01:29:10.455]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:10.455]                 }
[01:29:10.455]                 NAMES <- toupper(added)
[01:29:10.455]                 for (kk in seq_along(NAMES)) {
[01:29:10.455]                   name <- added[[kk]]
[01:29:10.455]                   NAME <- NAMES[[kk]]
[01:29:10.455]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:10.455]                     next
[01:29:10.455]                   args[[name]] <- ""
[01:29:10.455]                 }
[01:29:10.455]                 NAMES <- toupper(removed)
[01:29:10.455]                 for (kk in seq_along(NAMES)) {
[01:29:10.455]                   name <- removed[[kk]]
[01:29:10.455]                   NAME <- NAMES[[kk]]
[01:29:10.455]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:10.455]                     next
[01:29:10.455]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:10.455]                 }
[01:29:10.455]                 if (length(args) > 0) 
[01:29:10.455]                   base::do.call(base::Sys.setenv, args = args)
[01:29:10.455]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:10.455]             }
[01:29:10.455]             else {
[01:29:10.455]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:10.455]             }
[01:29:10.455]             {
[01:29:10.455]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:10.455]                   0L) {
[01:29:10.455]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:10.455]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:10.455]                   base::options(opts)
[01:29:10.455]                 }
[01:29:10.455]                 {
[01:29:10.455]                   {
[01:29:10.455]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:10.455]                     NULL
[01:29:10.455]                   }
[01:29:10.455]                   options(future.plan = NULL)
[01:29:10.455]                   if (is.na(NA_character_)) 
[01:29:10.455]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:10.455]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:10.455]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:10.455]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:10.455]                     envir = parent.frame()) 
[01:29:10.455]                   {
[01:29:10.455]                     if (is.function(workers)) 
[01:29:10.455]                       workers <- workers()
[01:29:10.455]                     workers <- structure(as.integer(workers), 
[01:29:10.455]                       class = class(workers))
[01:29:10.455]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:10.455]                       workers >= 1)
[01:29:10.455]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:10.455]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:10.455]                     }
[01:29:10.455]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:10.455]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:10.455]                       envir = envir)
[01:29:10.455]                     if (!future$lazy) 
[01:29:10.455]                       future <- run(future)
[01:29:10.455]                     invisible(future)
[01:29:10.455]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:10.455]                 }
[01:29:10.455]             }
[01:29:10.455]         }
[01:29:10.455]     })
[01:29:10.455]     if (TRUE) {
[01:29:10.455]         base::sink(type = "output", split = FALSE)
[01:29:10.455]         if (TRUE) {
[01:29:10.455]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:10.455]         }
[01:29:10.455]         else {
[01:29:10.455]             ...future.result["stdout"] <- base::list(NULL)
[01:29:10.455]         }
[01:29:10.455]         base::close(...future.stdout)
[01:29:10.455]         ...future.stdout <- NULL
[01:29:10.455]     }
[01:29:10.455]     ...future.result$conditions <- ...future.conditions
[01:29:10.455]     ...future.result$finished <- base::Sys.time()
[01:29:10.455]     ...future.result
[01:29:10.455] }
[01:29:10.461] MultisessionFuture started
[01:29:10.461] - Launch lazy future ... done
[01:29:10.461] run() for 'MultisessionFuture' ... done
[01:29:10.993] receiveMessageFromWorker() for ClusterFuture ...
[01:29:10.993] - Validating connection of MultisessionFuture
[01:29:10.994] - received message: FutureResult
[01:29:10.994] - Received FutureResult
[01:29:10.994] - Erased future from FutureRegistry
[01:29:10.994] result() for ClusterFuture ...
[01:29:10.995] - result already collected: FutureResult
[01:29:10.995] result() for ClusterFuture ... done
[01:29:10.995] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:10.995] resolve() on list ...
[01:29:10.995]  recursive: Inf
[01:29:10.995]  length: 2
[01:29:10.996]  elements: 'a', 'b'
[01:29:10.996]  length: 1 (resolved future 1)
[01:29:10.996]  length: 0 (resolved future 2)
[01:29:10.996] resolve() on list ... DONE
[01:29:10.996] A MultisessionFuture was resolved (and resolved itself)
[01:29:10.996] getGlobalsAndPackages() ...
[01:29:10.997] Searching for globals...
[01:29:10.998] - globals found: [3] '{', 'Sys.sleep', 'list'
[01:29:10.998] Searching for globals ... DONE
[01:29:10.999] Resolving globals: FALSE
[01:29:10.999] 
[01:29:10.999] 
[01:29:10.999] getGlobalsAndPackages() ... DONE
[01:29:11.000] run() for 'Future' ...
[01:29:11.000] - state: 'created'
[01:29:11.000] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:11.015] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:11.015] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:11.015]   - Field: 'node'
[01:29:11.016]   - Field: 'label'
[01:29:11.016]   - Field: 'local'
[01:29:11.016]   - Field: 'owner'
[01:29:11.016]   - Field: 'envir'
[01:29:11.016]   - Field: 'workers'
[01:29:11.016]   - Field: 'packages'
[01:29:11.017]   - Field: 'gc'
[01:29:11.017]   - Field: 'conditions'
[01:29:11.017]   - Field: 'persistent'
[01:29:11.017]   - Field: 'expr'
[01:29:11.017]   - Field: 'uuid'
[01:29:11.018]   - Field: 'seed'
[01:29:11.018]   - Field: 'version'
[01:29:11.018]   - Field: 'result'
[01:29:11.018]   - Field: 'asynchronous'
[01:29:11.018]   - Field: 'calls'
[01:29:11.018]   - Field: 'globals'
[01:29:11.019]   - Field: 'stdout'
[01:29:11.019]   - Field: 'earlySignal'
[01:29:11.019]   - Field: 'lazy'
[01:29:11.019]   - Field: 'state'
[01:29:11.019] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:11.019] - Launch lazy future ...
[01:29:11.020] Packages needed by the future expression (n = 0): <none>
[01:29:11.020] Packages needed by future strategies (n = 0): <none>
[01:29:11.021] {
[01:29:11.021]     {
[01:29:11.021]         {
[01:29:11.021]             ...future.startTime <- base::Sys.time()
[01:29:11.021]             {
[01:29:11.021]                 {
[01:29:11.021]                   {
[01:29:11.021]                     {
[01:29:11.021]                       base::local({
[01:29:11.021]                         has_future <- base::requireNamespace("future", 
[01:29:11.021]                           quietly = TRUE)
[01:29:11.021]                         if (has_future) {
[01:29:11.021]                           ns <- base::getNamespace("future")
[01:29:11.021]                           version <- ns[[".package"]][["version"]]
[01:29:11.021]                           if (is.null(version)) 
[01:29:11.021]                             version <- utils::packageVersion("future")
[01:29:11.021]                         }
[01:29:11.021]                         else {
[01:29:11.021]                           version <- NULL
[01:29:11.021]                         }
[01:29:11.021]                         if (!has_future || version < "1.8.0") {
[01:29:11.021]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:11.021]                             "", base::R.version$version.string), 
[01:29:11.021]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:11.021]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:11.021]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:11.021]                               "release", "version")], collapse = " "), 
[01:29:11.021]                             hostname = base::Sys.info()[["nodename"]])
[01:29:11.021]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:11.021]                             info)
[01:29:11.021]                           info <- base::paste(info, collapse = "; ")
[01:29:11.021]                           if (!has_future) {
[01:29:11.021]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:11.021]                               info)
[01:29:11.021]                           }
[01:29:11.021]                           else {
[01:29:11.021]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:11.021]                               info, version)
[01:29:11.021]                           }
[01:29:11.021]                           base::stop(msg)
[01:29:11.021]                         }
[01:29:11.021]                       })
[01:29:11.021]                     }
[01:29:11.021]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:11.021]                     base::options(mc.cores = 1L)
[01:29:11.021]                   }
[01:29:11.021]                   options(future.plan = NULL)
[01:29:11.021]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:11.021]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:11.021]                 }
[01:29:11.021]                 ...future.workdir <- getwd()
[01:29:11.021]             }
[01:29:11.021]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:11.021]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:11.021]         }
[01:29:11.021]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:11.021]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:11.021]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:11.021]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:11.021]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:11.021]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:11.021]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:11.021]             base::names(...future.oldOptions))
[01:29:11.021]     }
[01:29:11.021]     if (FALSE) {
[01:29:11.021]     }
[01:29:11.021]     else {
[01:29:11.021]         if (TRUE) {
[01:29:11.021]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:11.021]                 open = "w")
[01:29:11.021]         }
[01:29:11.021]         else {
[01:29:11.021]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:11.021]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:11.021]         }
[01:29:11.021]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:11.021]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:11.021]             base::sink(type = "output", split = FALSE)
[01:29:11.021]             base::close(...future.stdout)
[01:29:11.021]         }, add = TRUE)
[01:29:11.021]     }
[01:29:11.021]     ...future.frame <- base::sys.nframe()
[01:29:11.021]     ...future.conditions <- base::list()
[01:29:11.021]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:11.021]     if (FALSE) {
[01:29:11.021]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:11.021]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:11.021]     }
[01:29:11.021]     ...future.result <- base::tryCatch({
[01:29:11.021]         base::withCallingHandlers({
[01:29:11.021]             ...future.value <- base::withVisible(base::local({
[01:29:11.021]                 ...future.makeSendCondition <- base::local({
[01:29:11.021]                   sendCondition <- NULL
[01:29:11.021]                   function(frame = 1L) {
[01:29:11.021]                     if (is.function(sendCondition)) 
[01:29:11.021]                       return(sendCondition)
[01:29:11.021]                     ns <- getNamespace("parallel")
[01:29:11.021]                     if (exists("sendData", mode = "function", 
[01:29:11.021]                       envir = ns)) {
[01:29:11.021]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:11.021]                         envir = ns)
[01:29:11.021]                       envir <- sys.frame(frame)
[01:29:11.021]                       master <- NULL
[01:29:11.021]                       while (!identical(envir, .GlobalEnv) && 
[01:29:11.021]                         !identical(envir, emptyenv())) {
[01:29:11.021]                         if (exists("master", mode = "list", envir = envir, 
[01:29:11.021]                           inherits = FALSE)) {
[01:29:11.021]                           master <- get("master", mode = "list", 
[01:29:11.021]                             envir = envir, inherits = FALSE)
[01:29:11.021]                           if (inherits(master, c("SOCKnode", 
[01:29:11.021]                             "SOCK0node"))) {
[01:29:11.021]                             sendCondition <<- function(cond) {
[01:29:11.021]                               data <- list(type = "VALUE", value = cond, 
[01:29:11.021]                                 success = TRUE)
[01:29:11.021]                               parallel_sendData(master, data)
[01:29:11.021]                             }
[01:29:11.021]                             return(sendCondition)
[01:29:11.021]                           }
[01:29:11.021]                         }
[01:29:11.021]                         frame <- frame + 1L
[01:29:11.021]                         envir <- sys.frame(frame)
[01:29:11.021]                       }
[01:29:11.021]                     }
[01:29:11.021]                     sendCondition <<- function(cond) NULL
[01:29:11.021]                   }
[01:29:11.021]                 })
[01:29:11.021]                 withCallingHandlers({
[01:29:11.021]                   {
[01:29:11.021]                     Sys.sleep(0.5)
[01:29:11.021]                     list(a = 1, b = 42L)
[01:29:11.021]                   }
[01:29:11.021]                 }, immediateCondition = function(cond) {
[01:29:11.021]                   sendCondition <- ...future.makeSendCondition()
[01:29:11.021]                   sendCondition(cond)
[01:29:11.021]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:11.021]                   {
[01:29:11.021]                     inherits <- base::inherits
[01:29:11.021]                     invokeRestart <- base::invokeRestart
[01:29:11.021]                     is.null <- base::is.null
[01:29:11.021]                     muffled <- FALSE
[01:29:11.021]                     if (inherits(cond, "message")) {
[01:29:11.021]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:11.021]                       if (muffled) 
[01:29:11.021]                         invokeRestart("muffleMessage")
[01:29:11.021]                     }
[01:29:11.021]                     else if (inherits(cond, "warning")) {
[01:29:11.021]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:11.021]                       if (muffled) 
[01:29:11.021]                         invokeRestart("muffleWarning")
[01:29:11.021]                     }
[01:29:11.021]                     else if (inherits(cond, "condition")) {
[01:29:11.021]                       if (!is.null(pattern)) {
[01:29:11.021]                         computeRestarts <- base::computeRestarts
[01:29:11.021]                         grepl <- base::grepl
[01:29:11.021]                         restarts <- computeRestarts(cond)
[01:29:11.021]                         for (restart in restarts) {
[01:29:11.021]                           name <- restart$name
[01:29:11.021]                           if (is.null(name)) 
[01:29:11.021]                             next
[01:29:11.021]                           if (!grepl(pattern, name)) 
[01:29:11.021]                             next
[01:29:11.021]                           invokeRestart(restart)
[01:29:11.021]                           muffled <- TRUE
[01:29:11.021]                           break
[01:29:11.021]                         }
[01:29:11.021]                       }
[01:29:11.021]                     }
[01:29:11.021]                     invisible(muffled)
[01:29:11.021]                   }
[01:29:11.021]                   muffleCondition(cond)
[01:29:11.021]                 })
[01:29:11.021]             }))
[01:29:11.021]             future::FutureResult(value = ...future.value$value, 
[01:29:11.021]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:11.021]                   ...future.rng), globalenv = if (FALSE) 
[01:29:11.021]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:11.021]                     ...future.globalenv.names))
[01:29:11.021]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:11.021]         }, condition = base::local({
[01:29:11.021]             c <- base::c
[01:29:11.021]             inherits <- base::inherits
[01:29:11.021]             invokeRestart <- base::invokeRestart
[01:29:11.021]             length <- base::length
[01:29:11.021]             list <- base::list
[01:29:11.021]             seq.int <- base::seq.int
[01:29:11.021]             signalCondition <- base::signalCondition
[01:29:11.021]             sys.calls <- base::sys.calls
[01:29:11.021]             `[[` <- base::`[[`
[01:29:11.021]             `+` <- base::`+`
[01:29:11.021]             `<<-` <- base::`<<-`
[01:29:11.021]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:11.021]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:11.021]                   3L)]
[01:29:11.021]             }
[01:29:11.021]             function(cond) {
[01:29:11.021]                 is_error <- inherits(cond, "error")
[01:29:11.021]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:11.021]                   NULL)
[01:29:11.021]                 if (is_error) {
[01:29:11.021]                   sessionInformation <- function() {
[01:29:11.021]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:11.021]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:11.021]                       search = base::search(), system = base::Sys.info())
[01:29:11.021]                   }
[01:29:11.021]                   ...future.conditions[[length(...future.conditions) + 
[01:29:11.021]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:11.021]                     cond$call), session = sessionInformation(), 
[01:29:11.021]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:11.021]                   signalCondition(cond)
[01:29:11.021]                 }
[01:29:11.021]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:11.021]                 "immediateCondition"))) {
[01:29:11.021]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:11.021]                   ...future.conditions[[length(...future.conditions) + 
[01:29:11.021]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:11.021]                   if (TRUE && !signal) {
[01:29:11.021]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:11.021]                     {
[01:29:11.021]                       inherits <- base::inherits
[01:29:11.021]                       invokeRestart <- base::invokeRestart
[01:29:11.021]                       is.null <- base::is.null
[01:29:11.021]                       muffled <- FALSE
[01:29:11.021]                       if (inherits(cond, "message")) {
[01:29:11.021]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:11.021]                         if (muffled) 
[01:29:11.021]                           invokeRestart("muffleMessage")
[01:29:11.021]                       }
[01:29:11.021]                       else if (inherits(cond, "warning")) {
[01:29:11.021]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:11.021]                         if (muffled) 
[01:29:11.021]                           invokeRestart("muffleWarning")
[01:29:11.021]                       }
[01:29:11.021]                       else if (inherits(cond, "condition")) {
[01:29:11.021]                         if (!is.null(pattern)) {
[01:29:11.021]                           computeRestarts <- base::computeRestarts
[01:29:11.021]                           grepl <- base::grepl
[01:29:11.021]                           restarts <- computeRestarts(cond)
[01:29:11.021]                           for (restart in restarts) {
[01:29:11.021]                             name <- restart$name
[01:29:11.021]                             if (is.null(name)) 
[01:29:11.021]                               next
[01:29:11.021]                             if (!grepl(pattern, name)) 
[01:29:11.021]                               next
[01:29:11.021]                             invokeRestart(restart)
[01:29:11.021]                             muffled <- TRUE
[01:29:11.021]                             break
[01:29:11.021]                           }
[01:29:11.021]                         }
[01:29:11.021]                       }
[01:29:11.021]                       invisible(muffled)
[01:29:11.021]                     }
[01:29:11.021]                     muffleCondition(cond, pattern = "^muffle")
[01:29:11.021]                   }
[01:29:11.021]                 }
[01:29:11.021]                 else {
[01:29:11.021]                   if (TRUE) {
[01:29:11.021]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:11.021]                     {
[01:29:11.021]                       inherits <- base::inherits
[01:29:11.021]                       invokeRestart <- base::invokeRestart
[01:29:11.021]                       is.null <- base::is.null
[01:29:11.021]                       muffled <- FALSE
[01:29:11.021]                       if (inherits(cond, "message")) {
[01:29:11.021]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:11.021]                         if (muffled) 
[01:29:11.021]                           invokeRestart("muffleMessage")
[01:29:11.021]                       }
[01:29:11.021]                       else if (inherits(cond, "warning")) {
[01:29:11.021]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:11.021]                         if (muffled) 
[01:29:11.021]                           invokeRestart("muffleWarning")
[01:29:11.021]                       }
[01:29:11.021]                       else if (inherits(cond, "condition")) {
[01:29:11.021]                         if (!is.null(pattern)) {
[01:29:11.021]                           computeRestarts <- base::computeRestarts
[01:29:11.021]                           grepl <- base::grepl
[01:29:11.021]                           restarts <- computeRestarts(cond)
[01:29:11.021]                           for (restart in restarts) {
[01:29:11.021]                             name <- restart$name
[01:29:11.021]                             if (is.null(name)) 
[01:29:11.021]                               next
[01:29:11.021]                             if (!grepl(pattern, name)) 
[01:29:11.021]                               next
[01:29:11.021]                             invokeRestart(restart)
[01:29:11.021]                             muffled <- TRUE
[01:29:11.021]                             break
[01:29:11.021]                           }
[01:29:11.021]                         }
[01:29:11.021]                       }
[01:29:11.021]                       invisible(muffled)
[01:29:11.021]                     }
[01:29:11.021]                     muffleCondition(cond, pattern = "^muffle")
[01:29:11.021]                   }
[01:29:11.021]                 }
[01:29:11.021]             }
[01:29:11.021]         }))
[01:29:11.021]     }, error = function(ex) {
[01:29:11.021]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:11.021]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:11.021]                 ...future.rng), started = ...future.startTime, 
[01:29:11.021]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:11.021]             version = "1.8"), class = "FutureResult")
[01:29:11.021]     }, finally = {
[01:29:11.021]         if (!identical(...future.workdir, getwd())) 
[01:29:11.021]             setwd(...future.workdir)
[01:29:11.021]         {
[01:29:11.021]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:11.021]                 ...future.oldOptions$nwarnings <- NULL
[01:29:11.021]             }
[01:29:11.021]             base::options(...future.oldOptions)
[01:29:11.021]             if (.Platform$OS.type == "windows") {
[01:29:11.021]                 old_names <- names(...future.oldEnvVars)
[01:29:11.021]                 envs <- base::Sys.getenv()
[01:29:11.021]                 names <- names(envs)
[01:29:11.021]                 common <- intersect(names, old_names)
[01:29:11.021]                 added <- setdiff(names, old_names)
[01:29:11.021]                 removed <- setdiff(old_names, names)
[01:29:11.021]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:11.021]                   envs[common]]
[01:29:11.021]                 NAMES <- toupper(changed)
[01:29:11.021]                 args <- list()
[01:29:11.021]                 for (kk in seq_along(NAMES)) {
[01:29:11.021]                   name <- changed[[kk]]
[01:29:11.021]                   NAME <- NAMES[[kk]]
[01:29:11.021]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:11.021]                     next
[01:29:11.021]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:11.021]                 }
[01:29:11.021]                 NAMES <- toupper(added)
[01:29:11.021]                 for (kk in seq_along(NAMES)) {
[01:29:11.021]                   name <- added[[kk]]
[01:29:11.021]                   NAME <- NAMES[[kk]]
[01:29:11.021]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:11.021]                     next
[01:29:11.021]                   args[[name]] <- ""
[01:29:11.021]                 }
[01:29:11.021]                 NAMES <- toupper(removed)
[01:29:11.021]                 for (kk in seq_along(NAMES)) {
[01:29:11.021]                   name <- removed[[kk]]
[01:29:11.021]                   NAME <- NAMES[[kk]]
[01:29:11.021]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:11.021]                     next
[01:29:11.021]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:11.021]                 }
[01:29:11.021]                 if (length(args) > 0) 
[01:29:11.021]                   base::do.call(base::Sys.setenv, args = args)
[01:29:11.021]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:11.021]             }
[01:29:11.021]             else {
[01:29:11.021]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:11.021]             }
[01:29:11.021]             {
[01:29:11.021]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:11.021]                   0L) {
[01:29:11.021]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:11.021]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:11.021]                   base::options(opts)
[01:29:11.021]                 }
[01:29:11.021]                 {
[01:29:11.021]                   {
[01:29:11.021]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:11.021]                     NULL
[01:29:11.021]                   }
[01:29:11.021]                   options(future.plan = NULL)
[01:29:11.021]                   if (is.na(NA_character_)) 
[01:29:11.021]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:11.021]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:11.021]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:11.021]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:11.021]                     envir = parent.frame()) 
[01:29:11.021]                   {
[01:29:11.021]                     if (is.function(workers)) 
[01:29:11.021]                       workers <- workers()
[01:29:11.021]                     workers <- structure(as.integer(workers), 
[01:29:11.021]                       class = class(workers))
[01:29:11.021]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:11.021]                       workers >= 1)
[01:29:11.021]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:11.021]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:11.021]                     }
[01:29:11.021]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:11.021]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:11.021]                       envir = envir)
[01:29:11.021]                     if (!future$lazy) 
[01:29:11.021]                       future <- run(future)
[01:29:11.021]                     invisible(future)
[01:29:11.021]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:11.021]                 }
[01:29:11.021]             }
[01:29:11.021]         }
[01:29:11.021]     })
[01:29:11.021]     if (TRUE) {
[01:29:11.021]         base::sink(type = "output", split = FALSE)
[01:29:11.021]         if (TRUE) {
[01:29:11.021]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:11.021]         }
[01:29:11.021]         else {
[01:29:11.021]             ...future.result["stdout"] <- base::list(NULL)
[01:29:11.021]         }
[01:29:11.021]         base::close(...future.stdout)
[01:29:11.021]         ...future.stdout <- NULL
[01:29:11.021]     }
[01:29:11.021]     ...future.result$conditions <- ...future.conditions
[01:29:11.021]     ...future.result$finished <- base::Sys.time()
[01:29:11.021]     ...future.result
[01:29:11.021] }
[01:29:11.027] MultisessionFuture started
[01:29:11.027] - Launch lazy future ... done
[01:29:11.027] run() for 'MultisessionFuture' ... done
[01:29:11.549] receiveMessageFromWorker() for ClusterFuture ...
[01:29:11.549] - Validating connection of MultisessionFuture
[01:29:11.550] - received message: FutureResult
[01:29:11.550] - Received FutureResult
[01:29:11.550] - Erased future from FutureRegistry
[01:29:11.550] result() for ClusterFuture ...
[01:29:11.550] - result already collected: FutureResult
[01:29:11.551] result() for ClusterFuture ... done
[01:29:11.551] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:11.551] resolve() on list ...
[01:29:11.551]  recursive: Inf
[01:29:11.551]  length: 2
[01:29:11.551]  elements: 'a', 'b'
[01:29:11.552]  length: 1 (resolved future 1)
[01:29:11.552]  length: 0 (resolved future 2)
[01:29:11.552] resolve() on list ... DONE
[01:29:11.552] A MultisessionFuture was resolved (and resolved itself)
- w/ exception ...
[01:29:11.552] getGlobalsAndPackages() ...
[01:29:11.553] Searching for globals...
[01:29:11.553] - globals found: [2] 'list', 'stop'
[01:29:11.554] Searching for globals ... DONE
[01:29:11.554] Resolving globals: FALSE
[01:29:11.554] 
[01:29:11.554] 
[01:29:11.555] getGlobalsAndPackages() ... DONE
[01:29:11.555] run() for 'Future' ...
[01:29:11.555] - state: 'created'
[01:29:11.555] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:11.571] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:11.572] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:11.572]   - Field: 'node'
[01:29:11.572]   - Field: 'label'
[01:29:11.573]   - Field: 'local'
[01:29:11.573]   - Field: 'owner'
[01:29:11.573]   - Field: 'envir'
[01:29:11.574]   - Field: 'workers'
[01:29:11.574]   - Field: 'packages'
[01:29:11.574]   - Field: 'gc'
[01:29:11.575]   - Field: 'conditions'
[01:29:11.575]   - Field: 'persistent'
[01:29:11.575]   - Field: 'expr'
[01:29:11.576]   - Field: 'uuid'
[01:29:11.576]   - Field: 'seed'
[01:29:11.576]   - Field: 'version'
[01:29:11.576]   - Field: 'result'
[01:29:11.577]   - Field: 'asynchronous'
[01:29:11.577]   - Field: 'calls'
[01:29:11.578]   - Field: 'globals'
[01:29:11.578]   - Field: 'stdout'
[01:29:11.578]   - Field: 'earlySignal'
[01:29:11.578]   - Field: 'lazy'
[01:29:11.579]   - Field: 'state'
[01:29:11.579] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:11.579] - Launch lazy future ...
[01:29:11.580] Packages needed by the future expression (n = 0): <none>
[01:29:11.580] Packages needed by future strategies (n = 0): <none>
[01:29:11.581] {
[01:29:11.581]     {
[01:29:11.581]         {
[01:29:11.581]             ...future.startTime <- base::Sys.time()
[01:29:11.581]             {
[01:29:11.581]                 {
[01:29:11.581]                   {
[01:29:11.581]                     {
[01:29:11.581]                       base::local({
[01:29:11.581]                         has_future <- base::requireNamespace("future", 
[01:29:11.581]                           quietly = TRUE)
[01:29:11.581]                         if (has_future) {
[01:29:11.581]                           ns <- base::getNamespace("future")
[01:29:11.581]                           version <- ns[[".package"]][["version"]]
[01:29:11.581]                           if (is.null(version)) 
[01:29:11.581]                             version <- utils::packageVersion("future")
[01:29:11.581]                         }
[01:29:11.581]                         else {
[01:29:11.581]                           version <- NULL
[01:29:11.581]                         }
[01:29:11.581]                         if (!has_future || version < "1.8.0") {
[01:29:11.581]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:11.581]                             "", base::R.version$version.string), 
[01:29:11.581]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:11.581]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:11.581]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:11.581]                               "release", "version")], collapse = " "), 
[01:29:11.581]                             hostname = base::Sys.info()[["nodename"]])
[01:29:11.581]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:11.581]                             info)
[01:29:11.581]                           info <- base::paste(info, collapse = "; ")
[01:29:11.581]                           if (!has_future) {
[01:29:11.581]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:11.581]                               info)
[01:29:11.581]                           }
[01:29:11.581]                           else {
[01:29:11.581]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:11.581]                               info, version)
[01:29:11.581]                           }
[01:29:11.581]                           base::stop(msg)
[01:29:11.581]                         }
[01:29:11.581]                       })
[01:29:11.581]                     }
[01:29:11.581]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:11.581]                     base::options(mc.cores = 1L)
[01:29:11.581]                   }
[01:29:11.581]                   options(future.plan = NULL)
[01:29:11.581]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:11.581]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:11.581]                 }
[01:29:11.581]                 ...future.workdir <- getwd()
[01:29:11.581]             }
[01:29:11.581]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:11.581]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:11.581]         }
[01:29:11.581]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:11.581]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:11.581]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:11.581]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:11.581]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:11.581]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:11.581]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:11.581]             base::names(...future.oldOptions))
[01:29:11.581]     }
[01:29:11.581]     if (FALSE) {
[01:29:11.581]     }
[01:29:11.581]     else {
[01:29:11.581]         if (TRUE) {
[01:29:11.581]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:11.581]                 open = "w")
[01:29:11.581]         }
[01:29:11.581]         else {
[01:29:11.581]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:11.581]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:11.581]         }
[01:29:11.581]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:11.581]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:11.581]             base::sink(type = "output", split = FALSE)
[01:29:11.581]             base::close(...future.stdout)
[01:29:11.581]         }, add = TRUE)
[01:29:11.581]     }
[01:29:11.581]     ...future.frame <- base::sys.nframe()
[01:29:11.581]     ...future.conditions <- base::list()
[01:29:11.581]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:11.581]     if (FALSE) {
[01:29:11.581]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:11.581]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:11.581]     }
[01:29:11.581]     ...future.result <- base::tryCatch({
[01:29:11.581]         base::withCallingHandlers({
[01:29:11.581]             ...future.value <- base::withVisible(base::local({
[01:29:11.581]                 ...future.makeSendCondition <- base::local({
[01:29:11.581]                   sendCondition <- NULL
[01:29:11.581]                   function(frame = 1L) {
[01:29:11.581]                     if (is.function(sendCondition)) 
[01:29:11.581]                       return(sendCondition)
[01:29:11.581]                     ns <- getNamespace("parallel")
[01:29:11.581]                     if (exists("sendData", mode = "function", 
[01:29:11.581]                       envir = ns)) {
[01:29:11.581]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:11.581]                         envir = ns)
[01:29:11.581]                       envir <- sys.frame(frame)
[01:29:11.581]                       master <- NULL
[01:29:11.581]                       while (!identical(envir, .GlobalEnv) && 
[01:29:11.581]                         !identical(envir, emptyenv())) {
[01:29:11.581]                         if (exists("master", mode = "list", envir = envir, 
[01:29:11.581]                           inherits = FALSE)) {
[01:29:11.581]                           master <- get("master", mode = "list", 
[01:29:11.581]                             envir = envir, inherits = FALSE)
[01:29:11.581]                           if (inherits(master, c("SOCKnode", 
[01:29:11.581]                             "SOCK0node"))) {
[01:29:11.581]                             sendCondition <<- function(cond) {
[01:29:11.581]                               data <- list(type = "VALUE", value = cond, 
[01:29:11.581]                                 success = TRUE)
[01:29:11.581]                               parallel_sendData(master, data)
[01:29:11.581]                             }
[01:29:11.581]                             return(sendCondition)
[01:29:11.581]                           }
[01:29:11.581]                         }
[01:29:11.581]                         frame <- frame + 1L
[01:29:11.581]                         envir <- sys.frame(frame)
[01:29:11.581]                       }
[01:29:11.581]                     }
[01:29:11.581]                     sendCondition <<- function(cond) NULL
[01:29:11.581]                   }
[01:29:11.581]                 })
[01:29:11.581]                 withCallingHandlers({
[01:29:11.581]                   list(a = 1, b = 42L, c = stop("Nah!"))
[01:29:11.581]                 }, immediateCondition = function(cond) {
[01:29:11.581]                   sendCondition <- ...future.makeSendCondition()
[01:29:11.581]                   sendCondition(cond)
[01:29:11.581]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:11.581]                   {
[01:29:11.581]                     inherits <- base::inherits
[01:29:11.581]                     invokeRestart <- base::invokeRestart
[01:29:11.581]                     is.null <- base::is.null
[01:29:11.581]                     muffled <- FALSE
[01:29:11.581]                     if (inherits(cond, "message")) {
[01:29:11.581]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:11.581]                       if (muffled) 
[01:29:11.581]                         invokeRestart("muffleMessage")
[01:29:11.581]                     }
[01:29:11.581]                     else if (inherits(cond, "warning")) {
[01:29:11.581]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:11.581]                       if (muffled) 
[01:29:11.581]                         invokeRestart("muffleWarning")
[01:29:11.581]                     }
[01:29:11.581]                     else if (inherits(cond, "condition")) {
[01:29:11.581]                       if (!is.null(pattern)) {
[01:29:11.581]                         computeRestarts <- base::computeRestarts
[01:29:11.581]                         grepl <- base::grepl
[01:29:11.581]                         restarts <- computeRestarts(cond)
[01:29:11.581]                         for (restart in restarts) {
[01:29:11.581]                           name <- restart$name
[01:29:11.581]                           if (is.null(name)) 
[01:29:11.581]                             next
[01:29:11.581]                           if (!grepl(pattern, name)) 
[01:29:11.581]                             next
[01:29:11.581]                           invokeRestart(restart)
[01:29:11.581]                           muffled <- TRUE
[01:29:11.581]                           break
[01:29:11.581]                         }
[01:29:11.581]                       }
[01:29:11.581]                     }
[01:29:11.581]                     invisible(muffled)
[01:29:11.581]                   }
[01:29:11.581]                   muffleCondition(cond)
[01:29:11.581]                 })
[01:29:11.581]             }))
[01:29:11.581]             future::FutureResult(value = ...future.value$value, 
[01:29:11.581]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:11.581]                   ...future.rng), globalenv = if (FALSE) 
[01:29:11.581]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:11.581]                     ...future.globalenv.names))
[01:29:11.581]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:11.581]         }, condition = base::local({
[01:29:11.581]             c <- base::c
[01:29:11.581]             inherits <- base::inherits
[01:29:11.581]             invokeRestart <- base::invokeRestart
[01:29:11.581]             length <- base::length
[01:29:11.581]             list <- base::list
[01:29:11.581]             seq.int <- base::seq.int
[01:29:11.581]             signalCondition <- base::signalCondition
[01:29:11.581]             sys.calls <- base::sys.calls
[01:29:11.581]             `[[` <- base::`[[`
[01:29:11.581]             `+` <- base::`+`
[01:29:11.581]             `<<-` <- base::`<<-`
[01:29:11.581]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:11.581]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:11.581]                   3L)]
[01:29:11.581]             }
[01:29:11.581]             function(cond) {
[01:29:11.581]                 is_error <- inherits(cond, "error")
[01:29:11.581]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:11.581]                   NULL)
[01:29:11.581]                 if (is_error) {
[01:29:11.581]                   sessionInformation <- function() {
[01:29:11.581]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:11.581]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:11.581]                       search = base::search(), system = base::Sys.info())
[01:29:11.581]                   }
[01:29:11.581]                   ...future.conditions[[length(...future.conditions) + 
[01:29:11.581]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:11.581]                     cond$call), session = sessionInformation(), 
[01:29:11.581]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:11.581]                   signalCondition(cond)
[01:29:11.581]                 }
[01:29:11.581]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:11.581]                 "immediateCondition"))) {
[01:29:11.581]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:11.581]                   ...future.conditions[[length(...future.conditions) + 
[01:29:11.581]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:11.581]                   if (TRUE && !signal) {
[01:29:11.581]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:11.581]                     {
[01:29:11.581]                       inherits <- base::inherits
[01:29:11.581]                       invokeRestart <- base::invokeRestart
[01:29:11.581]                       is.null <- base::is.null
[01:29:11.581]                       muffled <- FALSE
[01:29:11.581]                       if (inherits(cond, "message")) {
[01:29:11.581]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:11.581]                         if (muffled) 
[01:29:11.581]                           invokeRestart("muffleMessage")
[01:29:11.581]                       }
[01:29:11.581]                       else if (inherits(cond, "warning")) {
[01:29:11.581]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:11.581]                         if (muffled) 
[01:29:11.581]                           invokeRestart("muffleWarning")
[01:29:11.581]                       }
[01:29:11.581]                       else if (inherits(cond, "condition")) {
[01:29:11.581]                         if (!is.null(pattern)) {
[01:29:11.581]                           computeRestarts <- base::computeRestarts
[01:29:11.581]                           grepl <- base::grepl
[01:29:11.581]                           restarts <- computeRestarts(cond)
[01:29:11.581]                           for (restart in restarts) {
[01:29:11.581]                             name <- restart$name
[01:29:11.581]                             if (is.null(name)) 
[01:29:11.581]                               next
[01:29:11.581]                             if (!grepl(pattern, name)) 
[01:29:11.581]                               next
[01:29:11.581]                             invokeRestart(restart)
[01:29:11.581]                             muffled <- TRUE
[01:29:11.581]                             break
[01:29:11.581]                           }
[01:29:11.581]                         }
[01:29:11.581]                       }
[01:29:11.581]                       invisible(muffled)
[01:29:11.581]                     }
[01:29:11.581]                     muffleCondition(cond, pattern = "^muffle")
[01:29:11.581]                   }
[01:29:11.581]                 }
[01:29:11.581]                 else {
[01:29:11.581]                   if (TRUE) {
[01:29:11.581]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:11.581]                     {
[01:29:11.581]                       inherits <- base::inherits
[01:29:11.581]                       invokeRestart <- base::invokeRestart
[01:29:11.581]                       is.null <- base::is.null
[01:29:11.581]                       muffled <- FALSE
[01:29:11.581]                       if (inherits(cond, "message")) {
[01:29:11.581]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:11.581]                         if (muffled) 
[01:29:11.581]                           invokeRestart("muffleMessage")
[01:29:11.581]                       }
[01:29:11.581]                       else if (inherits(cond, "warning")) {
[01:29:11.581]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:11.581]                         if (muffled) 
[01:29:11.581]                           invokeRestart("muffleWarning")
[01:29:11.581]                       }
[01:29:11.581]                       else if (inherits(cond, "condition")) {
[01:29:11.581]                         if (!is.null(pattern)) {
[01:29:11.581]                           computeRestarts <- base::computeRestarts
[01:29:11.581]                           grepl <- base::grepl
[01:29:11.581]                           restarts <- computeRestarts(cond)
[01:29:11.581]                           for (restart in restarts) {
[01:29:11.581]                             name <- restart$name
[01:29:11.581]                             if (is.null(name)) 
[01:29:11.581]                               next
[01:29:11.581]                             if (!grepl(pattern, name)) 
[01:29:11.581]                               next
[01:29:11.581]                             invokeRestart(restart)
[01:29:11.581]                             muffled <- TRUE
[01:29:11.581]                             break
[01:29:11.581]                           }
[01:29:11.581]                         }
[01:29:11.581]                       }
[01:29:11.581]                       invisible(muffled)
[01:29:11.581]                     }
[01:29:11.581]                     muffleCondition(cond, pattern = "^muffle")
[01:29:11.581]                   }
[01:29:11.581]                 }
[01:29:11.581]             }
[01:29:11.581]         }))
[01:29:11.581]     }, error = function(ex) {
[01:29:11.581]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:11.581]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:11.581]                 ...future.rng), started = ...future.startTime, 
[01:29:11.581]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:11.581]             version = "1.8"), class = "FutureResult")
[01:29:11.581]     }, finally = {
[01:29:11.581]         if (!identical(...future.workdir, getwd())) 
[01:29:11.581]             setwd(...future.workdir)
[01:29:11.581]         {
[01:29:11.581]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:11.581]                 ...future.oldOptions$nwarnings <- NULL
[01:29:11.581]             }
[01:29:11.581]             base::options(...future.oldOptions)
[01:29:11.581]             if (.Platform$OS.type == "windows") {
[01:29:11.581]                 old_names <- names(...future.oldEnvVars)
[01:29:11.581]                 envs <- base::Sys.getenv()
[01:29:11.581]                 names <- names(envs)
[01:29:11.581]                 common <- intersect(names, old_names)
[01:29:11.581]                 added <- setdiff(names, old_names)
[01:29:11.581]                 removed <- setdiff(old_names, names)
[01:29:11.581]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:11.581]                   envs[common]]
[01:29:11.581]                 NAMES <- toupper(changed)
[01:29:11.581]                 args <- list()
[01:29:11.581]                 for (kk in seq_along(NAMES)) {
[01:29:11.581]                   name <- changed[[kk]]
[01:29:11.581]                   NAME <- NAMES[[kk]]
[01:29:11.581]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:11.581]                     next
[01:29:11.581]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:11.581]                 }
[01:29:11.581]                 NAMES <- toupper(added)
[01:29:11.581]                 for (kk in seq_along(NAMES)) {
[01:29:11.581]                   name <- added[[kk]]
[01:29:11.581]                   NAME <- NAMES[[kk]]
[01:29:11.581]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:11.581]                     next
[01:29:11.581]                   args[[name]] <- ""
[01:29:11.581]                 }
[01:29:11.581]                 NAMES <- toupper(removed)
[01:29:11.581]                 for (kk in seq_along(NAMES)) {
[01:29:11.581]                   name <- removed[[kk]]
[01:29:11.581]                   NAME <- NAMES[[kk]]
[01:29:11.581]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:11.581]                     next
[01:29:11.581]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:11.581]                 }
[01:29:11.581]                 if (length(args) > 0) 
[01:29:11.581]                   base::do.call(base::Sys.setenv, args = args)
[01:29:11.581]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:11.581]             }
[01:29:11.581]             else {
[01:29:11.581]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:11.581]             }
[01:29:11.581]             {
[01:29:11.581]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:11.581]                   0L) {
[01:29:11.581]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:11.581]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:11.581]                   base::options(opts)
[01:29:11.581]                 }
[01:29:11.581]                 {
[01:29:11.581]                   {
[01:29:11.581]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:11.581]                     NULL
[01:29:11.581]                   }
[01:29:11.581]                   options(future.plan = NULL)
[01:29:11.581]                   if (is.na(NA_character_)) 
[01:29:11.581]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:11.581]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:11.581]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:11.581]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:11.581]                     envir = parent.frame()) 
[01:29:11.581]                   {
[01:29:11.581]                     if (is.function(workers)) 
[01:29:11.581]                       workers <- workers()
[01:29:11.581]                     workers <- structure(as.integer(workers), 
[01:29:11.581]                       class = class(workers))
[01:29:11.581]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:11.581]                       workers >= 1)
[01:29:11.581]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:11.581]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:11.581]                     }
[01:29:11.581]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:11.581]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:11.581]                       envir = envir)
[01:29:11.581]                     if (!future$lazy) 
[01:29:11.581]                       future <- run(future)
[01:29:11.581]                     invisible(future)
[01:29:11.581]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:11.581]                 }
[01:29:11.581]             }
[01:29:11.581]         }
[01:29:11.581]     })
[01:29:11.581]     if (TRUE) {
[01:29:11.581]         base::sink(type = "output", split = FALSE)
[01:29:11.581]         if (TRUE) {
[01:29:11.581]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:11.581]         }
[01:29:11.581]         else {
[01:29:11.581]             ...future.result["stdout"] <- base::list(NULL)
[01:29:11.581]         }
[01:29:11.581]         base::close(...future.stdout)
[01:29:11.581]         ...future.stdout <- NULL
[01:29:11.581]     }
[01:29:11.581]     ...future.result$conditions <- ...future.conditions
[01:29:11.581]     ...future.result$finished <- base::Sys.time()
[01:29:11.581]     ...future.result
[01:29:11.581] }
[01:29:11.591] MultisessionFuture started
[01:29:11.591] - Launch lazy future ... done
[01:29:11.591] run() for 'MultisessionFuture' ... done
[01:29:11.608] receiveMessageFromWorker() for ClusterFuture ...
[01:29:11.609] - Validating connection of MultisessionFuture
[01:29:11.609] - received message: FutureResult
[01:29:11.610] - Received FutureResult
[01:29:11.610] - Erased future from FutureRegistry
[01:29:11.610] result() for ClusterFuture ...
[01:29:11.610] - result already collected: FutureResult
[01:29:11.610] result() for ClusterFuture ... done
[01:29:11.610] signalConditions() ...
[01:29:11.611]  - include = 'immediateCondition'
[01:29:11.611]  - exclude = 
[01:29:11.611]  - resignal = FALSE
[01:29:11.611]  - Number of conditions: 1
[01:29:11.611] signalConditions() ... done
[01:29:11.612] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:11.612] A MultisessionFuture was resolved (and resolved itself)
[01:29:11.612] getGlobalsAndPackages() ...
[01:29:11.612] Searching for globals...
[01:29:11.613] - globals found: [2] 'list', 'stop'
[01:29:11.613] Searching for globals ... DONE
[01:29:11.613] Resolving globals: FALSE
[01:29:11.614] 
[01:29:11.614] 
[01:29:11.614] getGlobalsAndPackages() ... DONE
[01:29:11.614] run() for 'Future' ...
[01:29:11.615] - state: 'created'
[01:29:11.615] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:11.629] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:11.630] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:11.630]   - Field: 'node'
[01:29:11.630]   - Field: 'label'
[01:29:11.630]   - Field: 'local'
[01:29:11.630]   - Field: 'owner'
[01:29:11.631]   - Field: 'envir'
[01:29:11.631]   - Field: 'workers'
[01:29:11.631]   - Field: 'packages'
[01:29:11.631]   - Field: 'gc'
[01:29:11.631]   - Field: 'conditions'
[01:29:11.631]   - Field: 'persistent'
[01:29:11.632]   - Field: 'expr'
[01:29:11.632]   - Field: 'uuid'
[01:29:11.632]   - Field: 'seed'
[01:29:11.632]   - Field: 'version'
[01:29:11.632]   - Field: 'result'
[01:29:11.633]   - Field: 'asynchronous'
[01:29:11.633]   - Field: 'calls'
[01:29:11.633]   - Field: 'globals'
[01:29:11.633]   - Field: 'stdout'
[01:29:11.633]   - Field: 'earlySignal'
[01:29:11.633]   - Field: 'lazy'
[01:29:11.634]   - Field: 'state'
[01:29:11.634] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:11.634] - Launch lazy future ...
[01:29:11.634] Packages needed by the future expression (n = 0): <none>
[01:29:11.635] Packages needed by future strategies (n = 0): <none>
[01:29:11.638] {
[01:29:11.638]     {
[01:29:11.638]         {
[01:29:11.638]             ...future.startTime <- base::Sys.time()
[01:29:11.638]             {
[01:29:11.638]                 {
[01:29:11.638]                   {
[01:29:11.638]                     {
[01:29:11.638]                       base::local({
[01:29:11.638]                         has_future <- base::requireNamespace("future", 
[01:29:11.638]                           quietly = TRUE)
[01:29:11.638]                         if (has_future) {
[01:29:11.638]                           ns <- base::getNamespace("future")
[01:29:11.638]                           version <- ns[[".package"]][["version"]]
[01:29:11.638]                           if (is.null(version)) 
[01:29:11.638]                             version <- utils::packageVersion("future")
[01:29:11.638]                         }
[01:29:11.638]                         else {
[01:29:11.638]                           version <- NULL
[01:29:11.638]                         }
[01:29:11.638]                         if (!has_future || version < "1.8.0") {
[01:29:11.638]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:11.638]                             "", base::R.version$version.string), 
[01:29:11.638]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:11.638]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:11.638]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:11.638]                               "release", "version")], collapse = " "), 
[01:29:11.638]                             hostname = base::Sys.info()[["nodename"]])
[01:29:11.638]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:11.638]                             info)
[01:29:11.638]                           info <- base::paste(info, collapse = "; ")
[01:29:11.638]                           if (!has_future) {
[01:29:11.638]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:11.638]                               info)
[01:29:11.638]                           }
[01:29:11.638]                           else {
[01:29:11.638]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:11.638]                               info, version)
[01:29:11.638]                           }
[01:29:11.638]                           base::stop(msg)
[01:29:11.638]                         }
[01:29:11.638]                       })
[01:29:11.638]                     }
[01:29:11.638]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:11.638]                     base::options(mc.cores = 1L)
[01:29:11.638]                   }
[01:29:11.638]                   options(future.plan = NULL)
[01:29:11.638]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:11.638]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:11.638]                 }
[01:29:11.638]                 ...future.workdir <- getwd()
[01:29:11.638]             }
[01:29:11.638]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:11.638]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:11.638]         }
[01:29:11.638]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:11.638]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:11.638]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:11.638]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:11.638]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:11.638]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:11.638]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:11.638]             base::names(...future.oldOptions))
[01:29:11.638]     }
[01:29:11.638]     if (FALSE) {
[01:29:11.638]     }
[01:29:11.638]     else {
[01:29:11.638]         if (TRUE) {
[01:29:11.638]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:11.638]                 open = "w")
[01:29:11.638]         }
[01:29:11.638]         else {
[01:29:11.638]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:11.638]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:11.638]         }
[01:29:11.638]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:11.638]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:11.638]             base::sink(type = "output", split = FALSE)
[01:29:11.638]             base::close(...future.stdout)
[01:29:11.638]         }, add = TRUE)
[01:29:11.638]     }
[01:29:11.638]     ...future.frame <- base::sys.nframe()
[01:29:11.638]     ...future.conditions <- base::list()
[01:29:11.638]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:11.638]     if (FALSE) {
[01:29:11.638]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:11.638]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:11.638]     }
[01:29:11.638]     ...future.result <- base::tryCatch({
[01:29:11.638]         base::withCallingHandlers({
[01:29:11.638]             ...future.value <- base::withVisible(base::local({
[01:29:11.638]                 ...future.makeSendCondition <- base::local({
[01:29:11.638]                   sendCondition <- NULL
[01:29:11.638]                   function(frame = 1L) {
[01:29:11.638]                     if (is.function(sendCondition)) 
[01:29:11.638]                       return(sendCondition)
[01:29:11.638]                     ns <- getNamespace("parallel")
[01:29:11.638]                     if (exists("sendData", mode = "function", 
[01:29:11.638]                       envir = ns)) {
[01:29:11.638]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:11.638]                         envir = ns)
[01:29:11.638]                       envir <- sys.frame(frame)
[01:29:11.638]                       master <- NULL
[01:29:11.638]                       while (!identical(envir, .GlobalEnv) && 
[01:29:11.638]                         !identical(envir, emptyenv())) {
[01:29:11.638]                         if (exists("master", mode = "list", envir = envir, 
[01:29:11.638]                           inherits = FALSE)) {
[01:29:11.638]                           master <- get("master", mode = "list", 
[01:29:11.638]                             envir = envir, inherits = FALSE)
[01:29:11.638]                           if (inherits(master, c("SOCKnode", 
[01:29:11.638]                             "SOCK0node"))) {
[01:29:11.638]                             sendCondition <<- function(cond) {
[01:29:11.638]                               data <- list(type = "VALUE", value = cond, 
[01:29:11.638]                                 success = TRUE)
[01:29:11.638]                               parallel_sendData(master, data)
[01:29:11.638]                             }
[01:29:11.638]                             return(sendCondition)
[01:29:11.638]                           }
[01:29:11.638]                         }
[01:29:11.638]                         frame <- frame + 1L
[01:29:11.638]                         envir <- sys.frame(frame)
[01:29:11.638]                       }
[01:29:11.638]                     }
[01:29:11.638]                     sendCondition <<- function(cond) NULL
[01:29:11.638]                   }
[01:29:11.638]                 })
[01:29:11.638]                 withCallingHandlers({
[01:29:11.638]                   list(a = 1, b = 42L, c = stop("Nah!"))
[01:29:11.638]                 }, immediateCondition = function(cond) {
[01:29:11.638]                   sendCondition <- ...future.makeSendCondition()
[01:29:11.638]                   sendCondition(cond)
[01:29:11.638]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:11.638]                   {
[01:29:11.638]                     inherits <- base::inherits
[01:29:11.638]                     invokeRestart <- base::invokeRestart
[01:29:11.638]                     is.null <- base::is.null
[01:29:11.638]                     muffled <- FALSE
[01:29:11.638]                     if (inherits(cond, "message")) {
[01:29:11.638]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:11.638]                       if (muffled) 
[01:29:11.638]                         invokeRestart("muffleMessage")
[01:29:11.638]                     }
[01:29:11.638]                     else if (inherits(cond, "warning")) {
[01:29:11.638]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:11.638]                       if (muffled) 
[01:29:11.638]                         invokeRestart("muffleWarning")
[01:29:11.638]                     }
[01:29:11.638]                     else if (inherits(cond, "condition")) {
[01:29:11.638]                       if (!is.null(pattern)) {
[01:29:11.638]                         computeRestarts <- base::computeRestarts
[01:29:11.638]                         grepl <- base::grepl
[01:29:11.638]                         restarts <- computeRestarts(cond)
[01:29:11.638]                         for (restart in restarts) {
[01:29:11.638]                           name <- restart$name
[01:29:11.638]                           if (is.null(name)) 
[01:29:11.638]                             next
[01:29:11.638]                           if (!grepl(pattern, name)) 
[01:29:11.638]                             next
[01:29:11.638]                           invokeRestart(restart)
[01:29:11.638]                           muffled <- TRUE
[01:29:11.638]                           break
[01:29:11.638]                         }
[01:29:11.638]                       }
[01:29:11.638]                     }
[01:29:11.638]                     invisible(muffled)
[01:29:11.638]                   }
[01:29:11.638]                   muffleCondition(cond)
[01:29:11.638]                 })
[01:29:11.638]             }))
[01:29:11.638]             future::FutureResult(value = ...future.value$value, 
[01:29:11.638]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:11.638]                   ...future.rng), globalenv = if (FALSE) 
[01:29:11.638]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:11.638]                     ...future.globalenv.names))
[01:29:11.638]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:11.638]         }, condition = base::local({
[01:29:11.638]             c <- base::c
[01:29:11.638]             inherits <- base::inherits
[01:29:11.638]             invokeRestart <- base::invokeRestart
[01:29:11.638]             length <- base::length
[01:29:11.638]             list <- base::list
[01:29:11.638]             seq.int <- base::seq.int
[01:29:11.638]             signalCondition <- base::signalCondition
[01:29:11.638]             sys.calls <- base::sys.calls
[01:29:11.638]             `[[` <- base::`[[`
[01:29:11.638]             `+` <- base::`+`
[01:29:11.638]             `<<-` <- base::`<<-`
[01:29:11.638]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:11.638]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:11.638]                   3L)]
[01:29:11.638]             }
[01:29:11.638]             function(cond) {
[01:29:11.638]                 is_error <- inherits(cond, "error")
[01:29:11.638]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:11.638]                   NULL)
[01:29:11.638]                 if (is_error) {
[01:29:11.638]                   sessionInformation <- function() {
[01:29:11.638]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:11.638]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:11.638]                       search = base::search(), system = base::Sys.info())
[01:29:11.638]                   }
[01:29:11.638]                   ...future.conditions[[length(...future.conditions) + 
[01:29:11.638]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:11.638]                     cond$call), session = sessionInformation(), 
[01:29:11.638]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:11.638]                   signalCondition(cond)
[01:29:11.638]                 }
[01:29:11.638]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:11.638]                 "immediateCondition"))) {
[01:29:11.638]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:11.638]                   ...future.conditions[[length(...future.conditions) + 
[01:29:11.638]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:11.638]                   if (TRUE && !signal) {
[01:29:11.638]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:11.638]                     {
[01:29:11.638]                       inherits <- base::inherits
[01:29:11.638]                       invokeRestart <- base::invokeRestart
[01:29:11.638]                       is.null <- base::is.null
[01:29:11.638]                       muffled <- FALSE
[01:29:11.638]                       if (inherits(cond, "message")) {
[01:29:11.638]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:11.638]                         if (muffled) 
[01:29:11.638]                           invokeRestart("muffleMessage")
[01:29:11.638]                       }
[01:29:11.638]                       else if (inherits(cond, "warning")) {
[01:29:11.638]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:11.638]                         if (muffled) 
[01:29:11.638]                           invokeRestart("muffleWarning")
[01:29:11.638]                       }
[01:29:11.638]                       else if (inherits(cond, "condition")) {
[01:29:11.638]                         if (!is.null(pattern)) {
[01:29:11.638]                           computeRestarts <- base::computeRestarts
[01:29:11.638]                           grepl <- base::grepl
[01:29:11.638]                           restarts <- computeRestarts(cond)
[01:29:11.638]                           for (restart in restarts) {
[01:29:11.638]                             name <- restart$name
[01:29:11.638]                             if (is.null(name)) 
[01:29:11.638]                               next
[01:29:11.638]                             if (!grepl(pattern, name)) 
[01:29:11.638]                               next
[01:29:11.638]                             invokeRestart(restart)
[01:29:11.638]                             muffled <- TRUE
[01:29:11.638]                             break
[01:29:11.638]                           }
[01:29:11.638]                         }
[01:29:11.638]                       }
[01:29:11.638]                       invisible(muffled)
[01:29:11.638]                     }
[01:29:11.638]                     muffleCondition(cond, pattern = "^muffle")
[01:29:11.638]                   }
[01:29:11.638]                 }
[01:29:11.638]                 else {
[01:29:11.638]                   if (TRUE) {
[01:29:11.638]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:11.638]                     {
[01:29:11.638]                       inherits <- base::inherits
[01:29:11.638]                       invokeRestart <- base::invokeRestart
[01:29:11.638]                       is.null <- base::is.null
[01:29:11.638]                       muffled <- FALSE
[01:29:11.638]                       if (inherits(cond, "message")) {
[01:29:11.638]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:11.638]                         if (muffled) 
[01:29:11.638]                           invokeRestart("muffleMessage")
[01:29:11.638]                       }
[01:29:11.638]                       else if (inherits(cond, "warning")) {
[01:29:11.638]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:11.638]                         if (muffled) 
[01:29:11.638]                           invokeRestart("muffleWarning")
[01:29:11.638]                       }
[01:29:11.638]                       else if (inherits(cond, "condition")) {
[01:29:11.638]                         if (!is.null(pattern)) {
[01:29:11.638]                           computeRestarts <- base::computeRestarts
[01:29:11.638]                           grepl <- base::grepl
[01:29:11.638]                           restarts <- computeRestarts(cond)
[01:29:11.638]                           for (restart in restarts) {
[01:29:11.638]                             name <- restart$name
[01:29:11.638]                             if (is.null(name)) 
[01:29:11.638]                               next
[01:29:11.638]                             if (!grepl(pattern, name)) 
[01:29:11.638]                               next
[01:29:11.638]                             invokeRestart(restart)
[01:29:11.638]                             muffled <- TRUE
[01:29:11.638]                             break
[01:29:11.638]                           }
[01:29:11.638]                         }
[01:29:11.638]                       }
[01:29:11.638]                       invisible(muffled)
[01:29:11.638]                     }
[01:29:11.638]                     muffleCondition(cond, pattern = "^muffle")
[01:29:11.638]                   }
[01:29:11.638]                 }
[01:29:11.638]             }
[01:29:11.638]         }))
[01:29:11.638]     }, error = function(ex) {
[01:29:11.638]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:11.638]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:11.638]                 ...future.rng), started = ...future.startTime, 
[01:29:11.638]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:11.638]             version = "1.8"), class = "FutureResult")
[01:29:11.638]     }, finally = {
[01:29:11.638]         if (!identical(...future.workdir, getwd())) 
[01:29:11.638]             setwd(...future.workdir)
[01:29:11.638]         {
[01:29:11.638]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:11.638]                 ...future.oldOptions$nwarnings <- NULL
[01:29:11.638]             }
[01:29:11.638]             base::options(...future.oldOptions)
[01:29:11.638]             if (.Platform$OS.type == "windows") {
[01:29:11.638]                 old_names <- names(...future.oldEnvVars)
[01:29:11.638]                 envs <- base::Sys.getenv()
[01:29:11.638]                 names <- names(envs)
[01:29:11.638]                 common <- intersect(names, old_names)
[01:29:11.638]                 added <- setdiff(names, old_names)
[01:29:11.638]                 removed <- setdiff(old_names, names)
[01:29:11.638]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:11.638]                   envs[common]]
[01:29:11.638]                 NAMES <- toupper(changed)
[01:29:11.638]                 args <- list()
[01:29:11.638]                 for (kk in seq_along(NAMES)) {
[01:29:11.638]                   name <- changed[[kk]]
[01:29:11.638]                   NAME <- NAMES[[kk]]
[01:29:11.638]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:11.638]                     next
[01:29:11.638]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:11.638]                 }
[01:29:11.638]                 NAMES <- toupper(added)
[01:29:11.638]                 for (kk in seq_along(NAMES)) {
[01:29:11.638]                   name <- added[[kk]]
[01:29:11.638]                   NAME <- NAMES[[kk]]
[01:29:11.638]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:11.638]                     next
[01:29:11.638]                   args[[name]] <- ""
[01:29:11.638]                 }
[01:29:11.638]                 NAMES <- toupper(removed)
[01:29:11.638]                 for (kk in seq_along(NAMES)) {
[01:29:11.638]                   name <- removed[[kk]]
[01:29:11.638]                   NAME <- NAMES[[kk]]
[01:29:11.638]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:11.638]                     next
[01:29:11.638]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:11.638]                 }
[01:29:11.638]                 if (length(args) > 0) 
[01:29:11.638]                   base::do.call(base::Sys.setenv, args = args)
[01:29:11.638]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:11.638]             }
[01:29:11.638]             else {
[01:29:11.638]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:11.638]             }
[01:29:11.638]             {
[01:29:11.638]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:11.638]                   0L) {
[01:29:11.638]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:11.638]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:11.638]                   base::options(opts)
[01:29:11.638]                 }
[01:29:11.638]                 {
[01:29:11.638]                   {
[01:29:11.638]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:11.638]                     NULL
[01:29:11.638]                   }
[01:29:11.638]                   options(future.plan = NULL)
[01:29:11.638]                   if (is.na(NA_character_)) 
[01:29:11.638]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:11.638]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:11.638]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:11.638]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:11.638]                     envir = parent.frame()) 
[01:29:11.638]                   {
[01:29:11.638]                     if (is.function(workers)) 
[01:29:11.638]                       workers <- workers()
[01:29:11.638]                     workers <- structure(as.integer(workers), 
[01:29:11.638]                       class = class(workers))
[01:29:11.638]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:11.638]                       workers >= 1)
[01:29:11.638]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:11.638]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:11.638]                     }
[01:29:11.638]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:11.638]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:11.638]                       envir = envir)
[01:29:11.638]                     if (!future$lazy) 
[01:29:11.638]                       future <- run(future)
[01:29:11.638]                     invisible(future)
[01:29:11.638]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:11.638]                 }
[01:29:11.638]             }
[01:29:11.638]         }
[01:29:11.638]     })
[01:29:11.638]     if (TRUE) {
[01:29:11.638]         base::sink(type = "output", split = FALSE)
[01:29:11.638]         if (TRUE) {
[01:29:11.638]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:11.638]         }
[01:29:11.638]         else {
[01:29:11.638]             ...future.result["stdout"] <- base::list(NULL)
[01:29:11.638]         }
[01:29:11.638]         base::close(...future.stdout)
[01:29:11.638]         ...future.stdout <- NULL
[01:29:11.638]     }
[01:29:11.638]     ...future.result$conditions <- ...future.conditions
[01:29:11.638]     ...future.result$finished <- base::Sys.time()
[01:29:11.638]     ...future.result
[01:29:11.638] }
[01:29:11.644] MultisessionFuture started
[01:29:11.644] - Launch lazy future ... done
[01:29:11.644] run() for 'MultisessionFuture' ... done
[01:29:11.685] receiveMessageFromWorker() for ClusterFuture ...
[01:29:11.685] - Validating connection of MultisessionFuture
[01:29:11.686] - received message: FutureResult
[01:29:11.686] - Received FutureResult
[01:29:11.686] - Erased future from FutureRegistry
[01:29:11.686] result() for ClusterFuture ...
[01:29:11.686] - result already collected: FutureResult
[01:29:11.686] result() for ClusterFuture ... done
[01:29:11.687] signalConditions() ...
[01:29:11.687]  - include = 'immediateCondition'
[01:29:11.687]  - exclude = 
[01:29:11.687]  - resignal = FALSE
[01:29:11.687]  - Number of conditions: 1
[01:29:11.687] signalConditions() ... done
[01:29:11.688] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:11.688] A MultisessionFuture was resolved (and resolved itself)
- result = TRUE, recursive = Inf ... DONE
*** resolve() for Future objects ... DONE
*** resolve() for lists ...
[01:29:11.688] resolve() on list ...
[01:29:11.688]  recursive: 0
[01:29:11.689]  length: 2
[01:29:11.689]  elements: 'a', 'b'
[01:29:11.689]  length: 1 (resolved future 1)
[01:29:11.689]  length: 0 (resolved future 2)
[01:29:11.689] resolve() on list ... DONE
[01:29:11.690] getGlobalsAndPackages() ...
[01:29:11.690] Searching for globals...
[01:29:11.690] 
[01:29:11.690] Searching for globals ... DONE
[01:29:11.690] - globals: [0] <none>
[01:29:11.691] getGlobalsAndPackages() ... DONE
[01:29:11.691] run() for 'Future' ...
[01:29:11.691] - state: 'created'
[01:29:11.691] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:11.707] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:11.708] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:11.708]   - Field: 'node'
[01:29:11.709]   - Field: 'label'
[01:29:11.709]   - Field: 'local'
[01:29:11.709]   - Field: 'owner'
[01:29:11.709]   - Field: 'envir'
[01:29:11.710]   - Field: 'workers'
[01:29:11.710]   - Field: 'packages'
[01:29:11.710]   - Field: 'gc'
[01:29:11.710]   - Field: 'conditions'
[01:29:11.710]   - Field: 'persistent'
[01:29:11.711]   - Field: 'expr'
[01:29:11.711]   - Field: 'uuid'
[01:29:11.711]   - Field: 'seed'
[01:29:11.711]   - Field: 'version'
[01:29:11.711]   - Field: 'result'
[01:29:11.711]   - Field: 'asynchronous'
[01:29:11.712]   - Field: 'calls'
[01:29:11.712]   - Field: 'globals'
[01:29:11.712]   - Field: 'stdout'
[01:29:11.712]   - Field: 'earlySignal'
[01:29:11.713]   - Field: 'lazy'
[01:29:11.713]   - Field: 'state'
[01:29:11.713] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:11.713] - Launch lazy future ...
[01:29:11.714] Packages needed by the future expression (n = 0): <none>
[01:29:11.714] Packages needed by future strategies (n = 0): <none>
[01:29:11.715] {
[01:29:11.715]     {
[01:29:11.715]         {
[01:29:11.715]             ...future.startTime <- base::Sys.time()
[01:29:11.715]             {
[01:29:11.715]                 {
[01:29:11.715]                   {
[01:29:11.715]                     {
[01:29:11.715]                       base::local({
[01:29:11.715]                         has_future <- base::requireNamespace("future", 
[01:29:11.715]                           quietly = TRUE)
[01:29:11.715]                         if (has_future) {
[01:29:11.715]                           ns <- base::getNamespace("future")
[01:29:11.715]                           version <- ns[[".package"]][["version"]]
[01:29:11.715]                           if (is.null(version)) 
[01:29:11.715]                             version <- utils::packageVersion("future")
[01:29:11.715]                         }
[01:29:11.715]                         else {
[01:29:11.715]                           version <- NULL
[01:29:11.715]                         }
[01:29:11.715]                         if (!has_future || version < "1.8.0") {
[01:29:11.715]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:11.715]                             "", base::R.version$version.string), 
[01:29:11.715]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:11.715]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:11.715]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:11.715]                               "release", "version")], collapse = " "), 
[01:29:11.715]                             hostname = base::Sys.info()[["nodename"]])
[01:29:11.715]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:11.715]                             info)
[01:29:11.715]                           info <- base::paste(info, collapse = "; ")
[01:29:11.715]                           if (!has_future) {
[01:29:11.715]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:11.715]                               info)
[01:29:11.715]                           }
[01:29:11.715]                           else {
[01:29:11.715]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:11.715]                               info, version)
[01:29:11.715]                           }
[01:29:11.715]                           base::stop(msg)
[01:29:11.715]                         }
[01:29:11.715]                       })
[01:29:11.715]                     }
[01:29:11.715]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:11.715]                     base::options(mc.cores = 1L)
[01:29:11.715]                   }
[01:29:11.715]                   options(future.plan = NULL)
[01:29:11.715]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:11.715]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:11.715]                 }
[01:29:11.715]                 ...future.workdir <- getwd()
[01:29:11.715]             }
[01:29:11.715]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:11.715]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:11.715]         }
[01:29:11.715]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:11.715]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:11.715]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:11.715]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:11.715]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:11.715]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:11.715]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:11.715]             base::names(...future.oldOptions))
[01:29:11.715]     }
[01:29:11.715]     if (FALSE) {
[01:29:11.715]     }
[01:29:11.715]     else {
[01:29:11.715]         if (TRUE) {
[01:29:11.715]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:11.715]                 open = "w")
[01:29:11.715]         }
[01:29:11.715]         else {
[01:29:11.715]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:11.715]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:11.715]         }
[01:29:11.715]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:11.715]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:11.715]             base::sink(type = "output", split = FALSE)
[01:29:11.715]             base::close(...future.stdout)
[01:29:11.715]         }, add = TRUE)
[01:29:11.715]     }
[01:29:11.715]     ...future.frame <- base::sys.nframe()
[01:29:11.715]     ...future.conditions <- base::list()
[01:29:11.715]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:11.715]     if (FALSE) {
[01:29:11.715]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:11.715]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:11.715]     }
[01:29:11.715]     ...future.result <- base::tryCatch({
[01:29:11.715]         base::withCallingHandlers({
[01:29:11.715]             ...future.value <- base::withVisible(base::local({
[01:29:11.715]                 ...future.makeSendCondition <- base::local({
[01:29:11.715]                   sendCondition <- NULL
[01:29:11.715]                   function(frame = 1L) {
[01:29:11.715]                     if (is.function(sendCondition)) 
[01:29:11.715]                       return(sendCondition)
[01:29:11.715]                     ns <- getNamespace("parallel")
[01:29:11.715]                     if (exists("sendData", mode = "function", 
[01:29:11.715]                       envir = ns)) {
[01:29:11.715]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:11.715]                         envir = ns)
[01:29:11.715]                       envir <- sys.frame(frame)
[01:29:11.715]                       master <- NULL
[01:29:11.715]                       while (!identical(envir, .GlobalEnv) && 
[01:29:11.715]                         !identical(envir, emptyenv())) {
[01:29:11.715]                         if (exists("master", mode = "list", envir = envir, 
[01:29:11.715]                           inherits = FALSE)) {
[01:29:11.715]                           master <- get("master", mode = "list", 
[01:29:11.715]                             envir = envir, inherits = FALSE)
[01:29:11.715]                           if (inherits(master, c("SOCKnode", 
[01:29:11.715]                             "SOCK0node"))) {
[01:29:11.715]                             sendCondition <<- function(cond) {
[01:29:11.715]                               data <- list(type = "VALUE", value = cond, 
[01:29:11.715]                                 success = TRUE)
[01:29:11.715]                               parallel_sendData(master, data)
[01:29:11.715]                             }
[01:29:11.715]                             return(sendCondition)
[01:29:11.715]                           }
[01:29:11.715]                         }
[01:29:11.715]                         frame <- frame + 1L
[01:29:11.715]                         envir <- sys.frame(frame)
[01:29:11.715]                       }
[01:29:11.715]                     }
[01:29:11.715]                     sendCondition <<- function(cond) NULL
[01:29:11.715]                   }
[01:29:11.715]                 })
[01:29:11.715]                 withCallingHandlers({
[01:29:11.715]                   1
[01:29:11.715]                 }, immediateCondition = function(cond) {
[01:29:11.715]                   sendCondition <- ...future.makeSendCondition()
[01:29:11.715]                   sendCondition(cond)
[01:29:11.715]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:11.715]                   {
[01:29:11.715]                     inherits <- base::inherits
[01:29:11.715]                     invokeRestart <- base::invokeRestart
[01:29:11.715]                     is.null <- base::is.null
[01:29:11.715]                     muffled <- FALSE
[01:29:11.715]                     if (inherits(cond, "message")) {
[01:29:11.715]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:11.715]                       if (muffled) 
[01:29:11.715]                         invokeRestart("muffleMessage")
[01:29:11.715]                     }
[01:29:11.715]                     else if (inherits(cond, "warning")) {
[01:29:11.715]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:11.715]                       if (muffled) 
[01:29:11.715]                         invokeRestart("muffleWarning")
[01:29:11.715]                     }
[01:29:11.715]                     else if (inherits(cond, "condition")) {
[01:29:11.715]                       if (!is.null(pattern)) {
[01:29:11.715]                         computeRestarts <- base::computeRestarts
[01:29:11.715]                         grepl <- base::grepl
[01:29:11.715]                         restarts <- computeRestarts(cond)
[01:29:11.715]                         for (restart in restarts) {
[01:29:11.715]                           name <- restart$name
[01:29:11.715]                           if (is.null(name)) 
[01:29:11.715]                             next
[01:29:11.715]                           if (!grepl(pattern, name)) 
[01:29:11.715]                             next
[01:29:11.715]                           invokeRestart(restart)
[01:29:11.715]                           muffled <- TRUE
[01:29:11.715]                           break
[01:29:11.715]                         }
[01:29:11.715]                       }
[01:29:11.715]                     }
[01:29:11.715]                     invisible(muffled)
[01:29:11.715]                   }
[01:29:11.715]                   muffleCondition(cond)
[01:29:11.715]                 })
[01:29:11.715]             }))
[01:29:11.715]             future::FutureResult(value = ...future.value$value, 
[01:29:11.715]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:11.715]                   ...future.rng), globalenv = if (FALSE) 
[01:29:11.715]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:11.715]                     ...future.globalenv.names))
[01:29:11.715]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:11.715]         }, condition = base::local({
[01:29:11.715]             c <- base::c
[01:29:11.715]             inherits <- base::inherits
[01:29:11.715]             invokeRestart <- base::invokeRestart
[01:29:11.715]             length <- base::length
[01:29:11.715]             list <- base::list
[01:29:11.715]             seq.int <- base::seq.int
[01:29:11.715]             signalCondition <- base::signalCondition
[01:29:11.715]             sys.calls <- base::sys.calls
[01:29:11.715]             `[[` <- base::`[[`
[01:29:11.715]             `+` <- base::`+`
[01:29:11.715]             `<<-` <- base::`<<-`
[01:29:11.715]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:11.715]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:11.715]                   3L)]
[01:29:11.715]             }
[01:29:11.715]             function(cond) {
[01:29:11.715]                 is_error <- inherits(cond, "error")
[01:29:11.715]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:11.715]                   NULL)
[01:29:11.715]                 if (is_error) {
[01:29:11.715]                   sessionInformation <- function() {
[01:29:11.715]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:11.715]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:11.715]                       search = base::search(), system = base::Sys.info())
[01:29:11.715]                   }
[01:29:11.715]                   ...future.conditions[[length(...future.conditions) + 
[01:29:11.715]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:11.715]                     cond$call), session = sessionInformation(), 
[01:29:11.715]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:11.715]                   signalCondition(cond)
[01:29:11.715]                 }
[01:29:11.715]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:11.715]                 "immediateCondition"))) {
[01:29:11.715]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:11.715]                   ...future.conditions[[length(...future.conditions) + 
[01:29:11.715]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:11.715]                   if (TRUE && !signal) {
[01:29:11.715]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:11.715]                     {
[01:29:11.715]                       inherits <- base::inherits
[01:29:11.715]                       invokeRestart <- base::invokeRestart
[01:29:11.715]                       is.null <- base::is.null
[01:29:11.715]                       muffled <- FALSE
[01:29:11.715]                       if (inherits(cond, "message")) {
[01:29:11.715]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:11.715]                         if (muffled) 
[01:29:11.715]                           invokeRestart("muffleMessage")
[01:29:11.715]                       }
[01:29:11.715]                       else if (inherits(cond, "warning")) {
[01:29:11.715]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:11.715]                         if (muffled) 
[01:29:11.715]                           invokeRestart("muffleWarning")
[01:29:11.715]                       }
[01:29:11.715]                       else if (inherits(cond, "condition")) {
[01:29:11.715]                         if (!is.null(pattern)) {
[01:29:11.715]                           computeRestarts <- base::computeRestarts
[01:29:11.715]                           grepl <- base::grepl
[01:29:11.715]                           restarts <- computeRestarts(cond)
[01:29:11.715]                           for (restart in restarts) {
[01:29:11.715]                             name <- restart$name
[01:29:11.715]                             if (is.null(name)) 
[01:29:11.715]                               next
[01:29:11.715]                             if (!grepl(pattern, name)) 
[01:29:11.715]                               next
[01:29:11.715]                             invokeRestart(restart)
[01:29:11.715]                             muffled <- TRUE
[01:29:11.715]                             break
[01:29:11.715]                           }
[01:29:11.715]                         }
[01:29:11.715]                       }
[01:29:11.715]                       invisible(muffled)
[01:29:11.715]                     }
[01:29:11.715]                     muffleCondition(cond, pattern = "^muffle")
[01:29:11.715]                   }
[01:29:11.715]                 }
[01:29:11.715]                 else {
[01:29:11.715]                   if (TRUE) {
[01:29:11.715]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:11.715]                     {
[01:29:11.715]                       inherits <- base::inherits
[01:29:11.715]                       invokeRestart <- base::invokeRestart
[01:29:11.715]                       is.null <- base::is.null
[01:29:11.715]                       muffled <- FALSE
[01:29:11.715]                       if (inherits(cond, "message")) {
[01:29:11.715]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:11.715]                         if (muffled) 
[01:29:11.715]                           invokeRestart("muffleMessage")
[01:29:11.715]                       }
[01:29:11.715]                       else if (inherits(cond, "warning")) {
[01:29:11.715]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:11.715]                         if (muffled) 
[01:29:11.715]                           invokeRestart("muffleWarning")
[01:29:11.715]                       }
[01:29:11.715]                       else if (inherits(cond, "condition")) {
[01:29:11.715]                         if (!is.null(pattern)) {
[01:29:11.715]                           computeRestarts <- base::computeRestarts
[01:29:11.715]                           grepl <- base::grepl
[01:29:11.715]                           restarts <- computeRestarts(cond)
[01:29:11.715]                           for (restart in restarts) {
[01:29:11.715]                             name <- restart$name
[01:29:11.715]                             if (is.null(name)) 
[01:29:11.715]                               next
[01:29:11.715]                             if (!grepl(pattern, name)) 
[01:29:11.715]                               next
[01:29:11.715]                             invokeRestart(restart)
[01:29:11.715]                             muffled <- TRUE
[01:29:11.715]                             break
[01:29:11.715]                           }
[01:29:11.715]                         }
[01:29:11.715]                       }
[01:29:11.715]                       invisible(muffled)
[01:29:11.715]                     }
[01:29:11.715]                     muffleCondition(cond, pattern = "^muffle")
[01:29:11.715]                   }
[01:29:11.715]                 }
[01:29:11.715]             }
[01:29:11.715]         }))
[01:29:11.715]     }, error = function(ex) {
[01:29:11.715]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:11.715]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:11.715]                 ...future.rng), started = ...future.startTime, 
[01:29:11.715]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:11.715]             version = "1.8"), class = "FutureResult")
[01:29:11.715]     }, finally = {
[01:29:11.715]         if (!identical(...future.workdir, getwd())) 
[01:29:11.715]             setwd(...future.workdir)
[01:29:11.715]         {
[01:29:11.715]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:11.715]                 ...future.oldOptions$nwarnings <- NULL
[01:29:11.715]             }
[01:29:11.715]             base::options(...future.oldOptions)
[01:29:11.715]             if (.Platform$OS.type == "windows") {
[01:29:11.715]                 old_names <- names(...future.oldEnvVars)
[01:29:11.715]                 envs <- base::Sys.getenv()
[01:29:11.715]                 names <- names(envs)
[01:29:11.715]                 common <- intersect(names, old_names)
[01:29:11.715]                 added <- setdiff(names, old_names)
[01:29:11.715]                 removed <- setdiff(old_names, names)
[01:29:11.715]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:11.715]                   envs[common]]
[01:29:11.715]                 NAMES <- toupper(changed)
[01:29:11.715]                 args <- list()
[01:29:11.715]                 for (kk in seq_along(NAMES)) {
[01:29:11.715]                   name <- changed[[kk]]
[01:29:11.715]                   NAME <- NAMES[[kk]]
[01:29:11.715]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:11.715]                     next
[01:29:11.715]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:11.715]                 }
[01:29:11.715]                 NAMES <- toupper(added)
[01:29:11.715]                 for (kk in seq_along(NAMES)) {
[01:29:11.715]                   name <- added[[kk]]
[01:29:11.715]                   NAME <- NAMES[[kk]]
[01:29:11.715]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:11.715]                     next
[01:29:11.715]                   args[[name]] <- ""
[01:29:11.715]                 }
[01:29:11.715]                 NAMES <- toupper(removed)
[01:29:11.715]                 for (kk in seq_along(NAMES)) {
[01:29:11.715]                   name <- removed[[kk]]
[01:29:11.715]                   NAME <- NAMES[[kk]]
[01:29:11.715]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:11.715]                     next
[01:29:11.715]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:11.715]                 }
[01:29:11.715]                 if (length(args) > 0) 
[01:29:11.715]                   base::do.call(base::Sys.setenv, args = args)
[01:29:11.715]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:11.715]             }
[01:29:11.715]             else {
[01:29:11.715]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:11.715]             }
[01:29:11.715]             {
[01:29:11.715]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:11.715]                   0L) {
[01:29:11.715]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:11.715]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:11.715]                   base::options(opts)
[01:29:11.715]                 }
[01:29:11.715]                 {
[01:29:11.715]                   {
[01:29:11.715]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:11.715]                     NULL
[01:29:11.715]                   }
[01:29:11.715]                   options(future.plan = NULL)
[01:29:11.715]                   if (is.na(NA_character_)) 
[01:29:11.715]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:11.715]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:11.715]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:11.715]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:11.715]                     envir = parent.frame()) 
[01:29:11.715]                   {
[01:29:11.715]                     if (is.function(workers)) 
[01:29:11.715]                       workers <- workers()
[01:29:11.715]                     workers <- structure(as.integer(workers), 
[01:29:11.715]                       class = class(workers))
[01:29:11.715]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:11.715]                       workers >= 1)
[01:29:11.715]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:11.715]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:11.715]                     }
[01:29:11.715]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:11.715]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:11.715]                       envir = envir)
[01:29:11.715]                     if (!future$lazy) 
[01:29:11.715]                       future <- run(future)
[01:29:11.715]                     invisible(future)
[01:29:11.715]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:11.715]                 }
[01:29:11.715]             }
[01:29:11.715]         }
[01:29:11.715]     })
[01:29:11.715]     if (TRUE) {
[01:29:11.715]         base::sink(type = "output", split = FALSE)
[01:29:11.715]         if (TRUE) {
[01:29:11.715]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:11.715]         }
[01:29:11.715]         else {
[01:29:11.715]             ...future.result["stdout"] <- base::list(NULL)
[01:29:11.715]         }
[01:29:11.715]         base::close(...future.stdout)
[01:29:11.715]         ...future.stdout <- NULL
[01:29:11.715]     }
[01:29:11.715]     ...future.result$conditions <- ...future.conditions
[01:29:11.715]     ...future.result$finished <- base::Sys.time()
[01:29:11.715]     ...future.result
[01:29:11.715] }
[01:29:11.723] MultisessionFuture started
[01:29:11.723] - Launch lazy future ... done
[01:29:11.723] run() for 'MultisessionFuture' ... done
[01:29:11.724] getGlobalsAndPackages() ...
[01:29:11.724] Searching for globals...
[01:29:11.724] 
[01:29:11.724] Searching for globals ... DONE
[01:29:11.725] - globals: [0] <none>
[01:29:11.725] getGlobalsAndPackages() ... DONE
[01:29:11.725] run() for 'Future' ...
[01:29:11.725] - state: 'created'
[01:29:11.726] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:11.740] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:11.741] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:11.741]   - Field: 'node'
[01:29:11.741]   - Field: 'label'
[01:29:11.741]   - Field: 'local'
[01:29:11.742]   - Field: 'owner'
[01:29:11.742]   - Field: 'envir'
[01:29:11.742]   - Field: 'workers'
[01:29:11.742]   - Field: 'packages'
[01:29:11.743]   - Field: 'gc'
[01:29:11.743]   - Field: 'conditions'
[01:29:11.743]   - Field: 'persistent'
[01:29:11.743]   - Field: 'expr'
[01:29:11.743]   - Field: 'uuid'
[01:29:11.743]   - Field: 'seed'
[01:29:11.744]   - Field: 'version'
[01:29:11.744]   - Field: 'result'
[01:29:11.744]   - Field: 'asynchronous'
[01:29:11.744]   - Field: 'calls'
[01:29:11.744]   - Field: 'globals'
[01:29:11.745]   - Field: 'stdout'
[01:29:11.745]   - Field: 'earlySignal'
[01:29:11.745]   - Field: 'lazy'
[01:29:11.745]   - Field: 'state'
[01:29:11.745] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:11.746] - Launch lazy future ...
[01:29:11.746] Packages needed by the future expression (n = 0): <none>
[01:29:11.746] Packages needed by future strategies (n = 0): <none>
[01:29:11.747] {
[01:29:11.747]     {
[01:29:11.747]         {
[01:29:11.747]             ...future.startTime <- base::Sys.time()
[01:29:11.747]             {
[01:29:11.747]                 {
[01:29:11.747]                   {
[01:29:11.747]                     {
[01:29:11.747]                       base::local({
[01:29:11.747]                         has_future <- base::requireNamespace("future", 
[01:29:11.747]                           quietly = TRUE)
[01:29:11.747]                         if (has_future) {
[01:29:11.747]                           ns <- base::getNamespace("future")
[01:29:11.747]                           version <- ns[[".package"]][["version"]]
[01:29:11.747]                           if (is.null(version)) 
[01:29:11.747]                             version <- utils::packageVersion("future")
[01:29:11.747]                         }
[01:29:11.747]                         else {
[01:29:11.747]                           version <- NULL
[01:29:11.747]                         }
[01:29:11.747]                         if (!has_future || version < "1.8.0") {
[01:29:11.747]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:11.747]                             "", base::R.version$version.string), 
[01:29:11.747]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:11.747]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:11.747]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:11.747]                               "release", "version")], collapse = " "), 
[01:29:11.747]                             hostname = base::Sys.info()[["nodename"]])
[01:29:11.747]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:11.747]                             info)
[01:29:11.747]                           info <- base::paste(info, collapse = "; ")
[01:29:11.747]                           if (!has_future) {
[01:29:11.747]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:11.747]                               info)
[01:29:11.747]                           }
[01:29:11.747]                           else {
[01:29:11.747]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:11.747]                               info, version)
[01:29:11.747]                           }
[01:29:11.747]                           base::stop(msg)
[01:29:11.747]                         }
[01:29:11.747]                       })
[01:29:11.747]                     }
[01:29:11.747]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:11.747]                     base::options(mc.cores = 1L)
[01:29:11.747]                   }
[01:29:11.747]                   options(future.plan = NULL)
[01:29:11.747]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:11.747]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:11.747]                 }
[01:29:11.747]                 ...future.workdir <- getwd()
[01:29:11.747]             }
[01:29:11.747]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:11.747]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:11.747]         }
[01:29:11.747]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:11.747]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:11.747]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:11.747]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:11.747]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:11.747]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:11.747]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:11.747]             base::names(...future.oldOptions))
[01:29:11.747]     }
[01:29:11.747]     if (FALSE) {
[01:29:11.747]     }
[01:29:11.747]     else {
[01:29:11.747]         if (TRUE) {
[01:29:11.747]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:11.747]                 open = "w")
[01:29:11.747]         }
[01:29:11.747]         else {
[01:29:11.747]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:11.747]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:11.747]         }
[01:29:11.747]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:11.747]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:11.747]             base::sink(type = "output", split = FALSE)
[01:29:11.747]             base::close(...future.stdout)
[01:29:11.747]         }, add = TRUE)
[01:29:11.747]     }
[01:29:11.747]     ...future.frame <- base::sys.nframe()
[01:29:11.747]     ...future.conditions <- base::list()
[01:29:11.747]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:11.747]     if (FALSE) {
[01:29:11.747]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:11.747]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:11.747]     }
[01:29:11.747]     ...future.result <- base::tryCatch({
[01:29:11.747]         base::withCallingHandlers({
[01:29:11.747]             ...future.value <- base::withVisible(base::local({
[01:29:11.747]                 ...future.makeSendCondition <- base::local({
[01:29:11.747]                   sendCondition <- NULL
[01:29:11.747]                   function(frame = 1L) {
[01:29:11.747]                     if (is.function(sendCondition)) 
[01:29:11.747]                       return(sendCondition)
[01:29:11.747]                     ns <- getNamespace("parallel")
[01:29:11.747]                     if (exists("sendData", mode = "function", 
[01:29:11.747]                       envir = ns)) {
[01:29:11.747]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:11.747]                         envir = ns)
[01:29:11.747]                       envir <- sys.frame(frame)
[01:29:11.747]                       master <- NULL
[01:29:11.747]                       while (!identical(envir, .GlobalEnv) && 
[01:29:11.747]                         !identical(envir, emptyenv())) {
[01:29:11.747]                         if (exists("master", mode = "list", envir = envir, 
[01:29:11.747]                           inherits = FALSE)) {
[01:29:11.747]                           master <- get("master", mode = "list", 
[01:29:11.747]                             envir = envir, inherits = FALSE)
[01:29:11.747]                           if (inherits(master, c("SOCKnode", 
[01:29:11.747]                             "SOCK0node"))) {
[01:29:11.747]                             sendCondition <<- function(cond) {
[01:29:11.747]                               data <- list(type = "VALUE", value = cond, 
[01:29:11.747]                                 success = TRUE)
[01:29:11.747]                               parallel_sendData(master, data)
[01:29:11.747]                             }
[01:29:11.747]                             return(sendCondition)
[01:29:11.747]                           }
[01:29:11.747]                         }
[01:29:11.747]                         frame <- frame + 1L
[01:29:11.747]                         envir <- sys.frame(frame)
[01:29:11.747]                       }
[01:29:11.747]                     }
[01:29:11.747]                     sendCondition <<- function(cond) NULL
[01:29:11.747]                   }
[01:29:11.747]                 })
[01:29:11.747]                 withCallingHandlers({
[01:29:11.747]                   2
[01:29:11.747]                 }, immediateCondition = function(cond) {
[01:29:11.747]                   sendCondition <- ...future.makeSendCondition()
[01:29:11.747]                   sendCondition(cond)
[01:29:11.747]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:11.747]                   {
[01:29:11.747]                     inherits <- base::inherits
[01:29:11.747]                     invokeRestart <- base::invokeRestart
[01:29:11.747]                     is.null <- base::is.null
[01:29:11.747]                     muffled <- FALSE
[01:29:11.747]                     if (inherits(cond, "message")) {
[01:29:11.747]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:11.747]                       if (muffled) 
[01:29:11.747]                         invokeRestart("muffleMessage")
[01:29:11.747]                     }
[01:29:11.747]                     else if (inherits(cond, "warning")) {
[01:29:11.747]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:11.747]                       if (muffled) 
[01:29:11.747]                         invokeRestart("muffleWarning")
[01:29:11.747]                     }
[01:29:11.747]                     else if (inherits(cond, "condition")) {
[01:29:11.747]                       if (!is.null(pattern)) {
[01:29:11.747]                         computeRestarts <- base::computeRestarts
[01:29:11.747]                         grepl <- base::grepl
[01:29:11.747]                         restarts <- computeRestarts(cond)
[01:29:11.747]                         for (restart in restarts) {
[01:29:11.747]                           name <- restart$name
[01:29:11.747]                           if (is.null(name)) 
[01:29:11.747]                             next
[01:29:11.747]                           if (!grepl(pattern, name)) 
[01:29:11.747]                             next
[01:29:11.747]                           invokeRestart(restart)
[01:29:11.747]                           muffled <- TRUE
[01:29:11.747]                           break
[01:29:11.747]                         }
[01:29:11.747]                       }
[01:29:11.747]                     }
[01:29:11.747]                     invisible(muffled)
[01:29:11.747]                   }
[01:29:11.747]                   muffleCondition(cond)
[01:29:11.747]                 })
[01:29:11.747]             }))
[01:29:11.747]             future::FutureResult(value = ...future.value$value, 
[01:29:11.747]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:11.747]                   ...future.rng), globalenv = if (FALSE) 
[01:29:11.747]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:11.747]                     ...future.globalenv.names))
[01:29:11.747]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:11.747]         }, condition = base::local({
[01:29:11.747]             c <- base::c
[01:29:11.747]             inherits <- base::inherits
[01:29:11.747]             invokeRestart <- base::invokeRestart
[01:29:11.747]             length <- base::length
[01:29:11.747]             list <- base::list
[01:29:11.747]             seq.int <- base::seq.int
[01:29:11.747]             signalCondition <- base::signalCondition
[01:29:11.747]             sys.calls <- base::sys.calls
[01:29:11.747]             `[[` <- base::`[[`
[01:29:11.747]             `+` <- base::`+`
[01:29:11.747]             `<<-` <- base::`<<-`
[01:29:11.747]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:11.747]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:11.747]                   3L)]
[01:29:11.747]             }
[01:29:11.747]             function(cond) {
[01:29:11.747]                 is_error <- inherits(cond, "error")
[01:29:11.747]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:11.747]                   NULL)
[01:29:11.747]                 if (is_error) {
[01:29:11.747]                   sessionInformation <- function() {
[01:29:11.747]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:11.747]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:11.747]                       search = base::search(), system = base::Sys.info())
[01:29:11.747]                   }
[01:29:11.747]                   ...future.conditions[[length(...future.conditions) + 
[01:29:11.747]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:11.747]                     cond$call), session = sessionInformation(), 
[01:29:11.747]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:11.747]                   signalCondition(cond)
[01:29:11.747]                 }
[01:29:11.747]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:11.747]                 "immediateCondition"))) {
[01:29:11.747]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:11.747]                   ...future.conditions[[length(...future.conditions) + 
[01:29:11.747]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:11.747]                   if (TRUE && !signal) {
[01:29:11.747]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:11.747]                     {
[01:29:11.747]                       inherits <- base::inherits
[01:29:11.747]                       invokeRestart <- base::invokeRestart
[01:29:11.747]                       is.null <- base::is.null
[01:29:11.747]                       muffled <- FALSE
[01:29:11.747]                       if (inherits(cond, "message")) {
[01:29:11.747]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:11.747]                         if (muffled) 
[01:29:11.747]                           invokeRestart("muffleMessage")
[01:29:11.747]                       }
[01:29:11.747]                       else if (inherits(cond, "warning")) {
[01:29:11.747]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:11.747]                         if (muffled) 
[01:29:11.747]                           invokeRestart("muffleWarning")
[01:29:11.747]                       }
[01:29:11.747]                       else if (inherits(cond, "condition")) {
[01:29:11.747]                         if (!is.null(pattern)) {
[01:29:11.747]                           computeRestarts <- base::computeRestarts
[01:29:11.747]                           grepl <- base::grepl
[01:29:11.747]                           restarts <- computeRestarts(cond)
[01:29:11.747]                           for (restart in restarts) {
[01:29:11.747]                             name <- restart$name
[01:29:11.747]                             if (is.null(name)) 
[01:29:11.747]                               next
[01:29:11.747]                             if (!grepl(pattern, name)) 
[01:29:11.747]                               next
[01:29:11.747]                             invokeRestart(restart)
[01:29:11.747]                             muffled <- TRUE
[01:29:11.747]                             break
[01:29:11.747]                           }
[01:29:11.747]                         }
[01:29:11.747]                       }
[01:29:11.747]                       invisible(muffled)
[01:29:11.747]                     }
[01:29:11.747]                     muffleCondition(cond, pattern = "^muffle")
[01:29:11.747]                   }
[01:29:11.747]                 }
[01:29:11.747]                 else {
[01:29:11.747]                   if (TRUE) {
[01:29:11.747]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:11.747]                     {
[01:29:11.747]                       inherits <- base::inherits
[01:29:11.747]                       invokeRestart <- base::invokeRestart
[01:29:11.747]                       is.null <- base::is.null
[01:29:11.747]                       muffled <- FALSE
[01:29:11.747]                       if (inherits(cond, "message")) {
[01:29:11.747]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:11.747]                         if (muffled) 
[01:29:11.747]                           invokeRestart("muffleMessage")
[01:29:11.747]                       }
[01:29:11.747]                       else if (inherits(cond, "warning")) {
[01:29:11.747]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:11.747]                         if (muffled) 
[01:29:11.747]                           invokeRestart("muffleWarning")
[01:29:11.747]                       }
[01:29:11.747]                       else if (inherits(cond, "condition")) {
[01:29:11.747]                         if (!is.null(pattern)) {
[01:29:11.747]                           computeRestarts <- base::computeRestarts
[01:29:11.747]                           grepl <- base::grepl
[01:29:11.747]                           restarts <- computeRestarts(cond)
[01:29:11.747]                           for (restart in restarts) {
[01:29:11.747]                             name <- restart$name
[01:29:11.747]                             if (is.null(name)) 
[01:29:11.747]                               next
[01:29:11.747]                             if (!grepl(pattern, name)) 
[01:29:11.747]                               next
[01:29:11.747]                             invokeRestart(restart)
[01:29:11.747]                             muffled <- TRUE
[01:29:11.747]                             break
[01:29:11.747]                           }
[01:29:11.747]                         }
[01:29:11.747]                       }
[01:29:11.747]                       invisible(muffled)
[01:29:11.747]                     }
[01:29:11.747]                     muffleCondition(cond, pattern = "^muffle")
[01:29:11.747]                   }
[01:29:11.747]                 }
[01:29:11.747]             }
[01:29:11.747]         }))
[01:29:11.747]     }, error = function(ex) {
[01:29:11.747]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:11.747]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:11.747]                 ...future.rng), started = ...future.startTime, 
[01:29:11.747]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:11.747]             version = "1.8"), class = "FutureResult")
[01:29:11.747]     }, finally = {
[01:29:11.747]         if (!identical(...future.workdir, getwd())) 
[01:29:11.747]             setwd(...future.workdir)
[01:29:11.747]         {
[01:29:11.747]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:11.747]                 ...future.oldOptions$nwarnings <- NULL
[01:29:11.747]             }
[01:29:11.747]             base::options(...future.oldOptions)
[01:29:11.747]             if (.Platform$OS.type == "windows") {
[01:29:11.747]                 old_names <- names(...future.oldEnvVars)
[01:29:11.747]                 envs <- base::Sys.getenv()
[01:29:11.747]                 names <- names(envs)
[01:29:11.747]                 common <- intersect(names, old_names)
[01:29:11.747]                 added <- setdiff(names, old_names)
[01:29:11.747]                 removed <- setdiff(old_names, names)
[01:29:11.747]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:11.747]                   envs[common]]
[01:29:11.747]                 NAMES <- toupper(changed)
[01:29:11.747]                 args <- list()
[01:29:11.747]                 for (kk in seq_along(NAMES)) {
[01:29:11.747]                   name <- changed[[kk]]
[01:29:11.747]                   NAME <- NAMES[[kk]]
[01:29:11.747]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:11.747]                     next
[01:29:11.747]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:11.747]                 }
[01:29:11.747]                 NAMES <- toupper(added)
[01:29:11.747]                 for (kk in seq_along(NAMES)) {
[01:29:11.747]                   name <- added[[kk]]
[01:29:11.747]                   NAME <- NAMES[[kk]]
[01:29:11.747]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:11.747]                     next
[01:29:11.747]                   args[[name]] <- ""
[01:29:11.747]                 }
[01:29:11.747]                 NAMES <- toupper(removed)
[01:29:11.747]                 for (kk in seq_along(NAMES)) {
[01:29:11.747]                   name <- removed[[kk]]
[01:29:11.747]                   NAME <- NAMES[[kk]]
[01:29:11.747]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:11.747]                     next
[01:29:11.747]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:11.747]                 }
[01:29:11.747]                 if (length(args) > 0) 
[01:29:11.747]                   base::do.call(base::Sys.setenv, args = args)
[01:29:11.747]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:11.747]             }
[01:29:11.747]             else {
[01:29:11.747]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:11.747]             }
[01:29:11.747]             {
[01:29:11.747]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:11.747]                   0L) {
[01:29:11.747]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:11.747]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:11.747]                   base::options(opts)
[01:29:11.747]                 }
[01:29:11.747]                 {
[01:29:11.747]                   {
[01:29:11.747]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:11.747]                     NULL
[01:29:11.747]                   }
[01:29:11.747]                   options(future.plan = NULL)
[01:29:11.747]                   if (is.na(NA_character_)) 
[01:29:11.747]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:11.747]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:11.747]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:11.747]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:11.747]                     envir = parent.frame()) 
[01:29:11.747]                   {
[01:29:11.747]                     if (is.function(workers)) 
[01:29:11.747]                       workers <- workers()
[01:29:11.747]                     workers <- structure(as.integer(workers), 
[01:29:11.747]                       class = class(workers))
[01:29:11.747]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:11.747]                       workers >= 1)
[01:29:11.747]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:11.747]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:11.747]                     }
[01:29:11.747]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:11.747]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:11.747]                       envir = envir)
[01:29:11.747]                     if (!future$lazy) 
[01:29:11.747]                       future <- run(future)
[01:29:11.747]                     invisible(future)
[01:29:11.747]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:11.747]                 }
[01:29:11.747]             }
[01:29:11.747]         }
[01:29:11.747]     })
[01:29:11.747]     if (TRUE) {
[01:29:11.747]         base::sink(type = "output", split = FALSE)
[01:29:11.747]         if (TRUE) {
[01:29:11.747]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:11.747]         }
[01:29:11.747]         else {
[01:29:11.747]             ...future.result["stdout"] <- base::list(NULL)
[01:29:11.747]         }
[01:29:11.747]         base::close(...future.stdout)
[01:29:11.747]         ...future.stdout <- NULL
[01:29:11.747]     }
[01:29:11.747]     ...future.result$conditions <- ...future.conditions
[01:29:11.747]     ...future.result$finished <- base::Sys.time()
[01:29:11.747]     ...future.result
[01:29:11.747] }
[01:29:11.753] Poll #1 (0): usedNodes() = 2, workers = 2
[01:29:11.766] receiveMessageFromWorker() for ClusterFuture ...
[01:29:11.767] - Validating connection of MultisessionFuture
[01:29:11.767] - received message: FutureResult
[01:29:11.767] - Received FutureResult
[01:29:11.767] - Erased future from FutureRegistry
[01:29:11.767] result() for ClusterFuture ...
[01:29:11.768] - result already collected: FutureResult
[01:29:11.768] result() for ClusterFuture ... done
[01:29:11.768] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:11.768] result() for ClusterFuture ...
[01:29:11.768] - result already collected: FutureResult
[01:29:11.769] result() for ClusterFuture ... done
[01:29:11.769] result() for ClusterFuture ...
[01:29:11.769] - result already collected: FutureResult
[01:29:11.769] result() for ClusterFuture ... done
[01:29:11.771] MultisessionFuture started
[01:29:11.771] - Launch lazy future ... done
[01:29:11.771] run() for 'MultisessionFuture' ... done
[01:29:11.771] resolve() on list ...
[01:29:11.771]  recursive: 0
[01:29:11.772]  length: 3
[01:29:11.772]  elements: 'a', 'b', ''
[01:29:11.772] receiveMessageFromWorker() for ClusterFuture ...
[01:29:11.772] - Validating connection of MultisessionFuture
[01:29:11.773] - received message: FutureResult
[01:29:11.773] - Received FutureResult
[01:29:11.773] - Erased future from FutureRegistry
[01:29:11.773] result() for ClusterFuture ...
[01:29:11.773] - result already collected: FutureResult
[01:29:11.774] result() for ClusterFuture ... done
[01:29:11.774] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:11.774] Future #1
[01:29:11.774]  length: 2 (resolved future 1)
[01:29:11.814] receiveMessageFromWorker() for ClusterFuture ...
[01:29:11.815] - Validating connection of MultisessionFuture
[01:29:11.815] - received message: FutureResult
[01:29:11.815] - Received FutureResult
[01:29:11.815] - Erased future from FutureRegistry
[01:29:11.816] result() for ClusterFuture ...
[01:29:11.816] - result already collected: FutureResult
[01:29:11.816] result() for ClusterFuture ... done
[01:29:11.816] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:11.816] Future #2
[01:29:11.817]  length: 1 (resolved future 2)
[01:29:11.817]  length: 0 (resolved future 3)
[01:29:11.817] resolve() on list ... DONE
[01:29:11.817] getGlobalsAndPackages() ...
[01:29:11.817] Searching for globals...
[01:29:11.818] 
[01:29:11.818] Searching for globals ... DONE
[01:29:11.818] - globals: [0] <none>
[01:29:11.818] getGlobalsAndPackages() ... DONE
[01:29:11.819] getGlobalsAndPackages() ...
[01:29:11.819] Searching for globals...
[01:29:11.819] 
[01:29:11.820] Searching for globals ... DONE
[01:29:11.820] - globals: [0] <none>
[01:29:11.820] getGlobalsAndPackages() ... DONE
[01:29:11.820] run() for 'Future' ...
[01:29:11.820] - state: 'created'
[01:29:11.821] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:11.836] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:11.836] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:11.836]   - Field: 'node'
[01:29:11.837]   - Field: 'label'
[01:29:11.837]   - Field: 'local'
[01:29:11.837]   - Field: 'owner'
[01:29:11.837]   - Field: 'envir'
[01:29:11.837]   - Field: 'workers'
[01:29:11.838]   - Field: 'packages'
[01:29:11.838]   - Field: 'gc'
[01:29:11.838]   - Field: 'conditions'
[01:29:11.838]   - Field: 'persistent'
[01:29:11.838]   - Field: 'expr'
[01:29:11.839]   - Field: 'uuid'
[01:29:11.839]   - Field: 'seed'
[01:29:11.839]   - Field: 'version'
[01:29:11.839]   - Field: 'result'
[01:29:11.839]   - Field: 'asynchronous'
[01:29:11.839]   - Field: 'calls'
[01:29:11.840]   - Field: 'globals'
[01:29:11.840]   - Field: 'stdout'
[01:29:11.840]   - Field: 'earlySignal'
[01:29:11.840]   - Field: 'lazy'
[01:29:11.840]   - Field: 'state'
[01:29:11.841] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:11.841] - Launch lazy future ...
[01:29:11.841] Packages needed by the future expression (n = 0): <none>
[01:29:11.841] Packages needed by future strategies (n = 0): <none>
[01:29:11.842] {
[01:29:11.842]     {
[01:29:11.842]         {
[01:29:11.842]             ...future.startTime <- base::Sys.time()
[01:29:11.842]             {
[01:29:11.842]                 {
[01:29:11.842]                   {
[01:29:11.842]                     {
[01:29:11.842]                       base::local({
[01:29:11.842]                         has_future <- base::requireNamespace("future", 
[01:29:11.842]                           quietly = TRUE)
[01:29:11.842]                         if (has_future) {
[01:29:11.842]                           ns <- base::getNamespace("future")
[01:29:11.842]                           version <- ns[[".package"]][["version"]]
[01:29:11.842]                           if (is.null(version)) 
[01:29:11.842]                             version <- utils::packageVersion("future")
[01:29:11.842]                         }
[01:29:11.842]                         else {
[01:29:11.842]                           version <- NULL
[01:29:11.842]                         }
[01:29:11.842]                         if (!has_future || version < "1.8.0") {
[01:29:11.842]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:11.842]                             "", base::R.version$version.string), 
[01:29:11.842]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:11.842]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:11.842]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:11.842]                               "release", "version")], collapse = " "), 
[01:29:11.842]                             hostname = base::Sys.info()[["nodename"]])
[01:29:11.842]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:11.842]                             info)
[01:29:11.842]                           info <- base::paste(info, collapse = "; ")
[01:29:11.842]                           if (!has_future) {
[01:29:11.842]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:11.842]                               info)
[01:29:11.842]                           }
[01:29:11.842]                           else {
[01:29:11.842]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:11.842]                               info, version)
[01:29:11.842]                           }
[01:29:11.842]                           base::stop(msg)
[01:29:11.842]                         }
[01:29:11.842]                       })
[01:29:11.842]                     }
[01:29:11.842]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:11.842]                     base::options(mc.cores = 1L)
[01:29:11.842]                   }
[01:29:11.842]                   options(future.plan = NULL)
[01:29:11.842]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:11.842]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:11.842]                 }
[01:29:11.842]                 ...future.workdir <- getwd()
[01:29:11.842]             }
[01:29:11.842]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:11.842]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:11.842]         }
[01:29:11.842]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:11.842]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:11.842]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:11.842]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:11.842]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:11.842]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:11.842]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:11.842]             base::names(...future.oldOptions))
[01:29:11.842]     }
[01:29:11.842]     if (FALSE) {
[01:29:11.842]     }
[01:29:11.842]     else {
[01:29:11.842]         if (TRUE) {
[01:29:11.842]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:11.842]                 open = "w")
[01:29:11.842]         }
[01:29:11.842]         else {
[01:29:11.842]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:11.842]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:11.842]         }
[01:29:11.842]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:11.842]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:11.842]             base::sink(type = "output", split = FALSE)
[01:29:11.842]             base::close(...future.stdout)
[01:29:11.842]         }, add = TRUE)
[01:29:11.842]     }
[01:29:11.842]     ...future.frame <- base::sys.nframe()
[01:29:11.842]     ...future.conditions <- base::list()
[01:29:11.842]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:11.842]     if (FALSE) {
[01:29:11.842]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:11.842]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:11.842]     }
[01:29:11.842]     ...future.result <- base::tryCatch({
[01:29:11.842]         base::withCallingHandlers({
[01:29:11.842]             ...future.value <- base::withVisible(base::local({
[01:29:11.842]                 ...future.makeSendCondition <- base::local({
[01:29:11.842]                   sendCondition <- NULL
[01:29:11.842]                   function(frame = 1L) {
[01:29:11.842]                     if (is.function(sendCondition)) 
[01:29:11.842]                       return(sendCondition)
[01:29:11.842]                     ns <- getNamespace("parallel")
[01:29:11.842]                     if (exists("sendData", mode = "function", 
[01:29:11.842]                       envir = ns)) {
[01:29:11.842]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:11.842]                         envir = ns)
[01:29:11.842]                       envir <- sys.frame(frame)
[01:29:11.842]                       master <- NULL
[01:29:11.842]                       while (!identical(envir, .GlobalEnv) && 
[01:29:11.842]                         !identical(envir, emptyenv())) {
[01:29:11.842]                         if (exists("master", mode = "list", envir = envir, 
[01:29:11.842]                           inherits = FALSE)) {
[01:29:11.842]                           master <- get("master", mode = "list", 
[01:29:11.842]                             envir = envir, inherits = FALSE)
[01:29:11.842]                           if (inherits(master, c("SOCKnode", 
[01:29:11.842]                             "SOCK0node"))) {
[01:29:11.842]                             sendCondition <<- function(cond) {
[01:29:11.842]                               data <- list(type = "VALUE", value = cond, 
[01:29:11.842]                                 success = TRUE)
[01:29:11.842]                               parallel_sendData(master, data)
[01:29:11.842]                             }
[01:29:11.842]                             return(sendCondition)
[01:29:11.842]                           }
[01:29:11.842]                         }
[01:29:11.842]                         frame <- frame + 1L
[01:29:11.842]                         envir <- sys.frame(frame)
[01:29:11.842]                       }
[01:29:11.842]                     }
[01:29:11.842]                     sendCondition <<- function(cond) NULL
[01:29:11.842]                   }
[01:29:11.842]                 })
[01:29:11.842]                 withCallingHandlers({
[01:29:11.842]                   2
[01:29:11.842]                 }, immediateCondition = function(cond) {
[01:29:11.842]                   sendCondition <- ...future.makeSendCondition()
[01:29:11.842]                   sendCondition(cond)
[01:29:11.842]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:11.842]                   {
[01:29:11.842]                     inherits <- base::inherits
[01:29:11.842]                     invokeRestart <- base::invokeRestart
[01:29:11.842]                     is.null <- base::is.null
[01:29:11.842]                     muffled <- FALSE
[01:29:11.842]                     if (inherits(cond, "message")) {
[01:29:11.842]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:11.842]                       if (muffled) 
[01:29:11.842]                         invokeRestart("muffleMessage")
[01:29:11.842]                     }
[01:29:11.842]                     else if (inherits(cond, "warning")) {
[01:29:11.842]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:11.842]                       if (muffled) 
[01:29:11.842]                         invokeRestart("muffleWarning")
[01:29:11.842]                     }
[01:29:11.842]                     else if (inherits(cond, "condition")) {
[01:29:11.842]                       if (!is.null(pattern)) {
[01:29:11.842]                         computeRestarts <- base::computeRestarts
[01:29:11.842]                         grepl <- base::grepl
[01:29:11.842]                         restarts <- computeRestarts(cond)
[01:29:11.842]                         for (restart in restarts) {
[01:29:11.842]                           name <- restart$name
[01:29:11.842]                           if (is.null(name)) 
[01:29:11.842]                             next
[01:29:11.842]                           if (!grepl(pattern, name)) 
[01:29:11.842]                             next
[01:29:11.842]                           invokeRestart(restart)
[01:29:11.842]                           muffled <- TRUE
[01:29:11.842]                           break
[01:29:11.842]                         }
[01:29:11.842]                       }
[01:29:11.842]                     }
[01:29:11.842]                     invisible(muffled)
[01:29:11.842]                   }
[01:29:11.842]                   muffleCondition(cond)
[01:29:11.842]                 })
[01:29:11.842]             }))
[01:29:11.842]             future::FutureResult(value = ...future.value$value, 
[01:29:11.842]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:11.842]                   ...future.rng), globalenv = if (FALSE) 
[01:29:11.842]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:11.842]                     ...future.globalenv.names))
[01:29:11.842]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:11.842]         }, condition = base::local({
[01:29:11.842]             c <- base::c
[01:29:11.842]             inherits <- base::inherits
[01:29:11.842]             invokeRestart <- base::invokeRestart
[01:29:11.842]             length <- base::length
[01:29:11.842]             list <- base::list
[01:29:11.842]             seq.int <- base::seq.int
[01:29:11.842]             signalCondition <- base::signalCondition
[01:29:11.842]             sys.calls <- base::sys.calls
[01:29:11.842]             `[[` <- base::`[[`
[01:29:11.842]             `+` <- base::`+`
[01:29:11.842]             `<<-` <- base::`<<-`
[01:29:11.842]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:11.842]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:11.842]                   3L)]
[01:29:11.842]             }
[01:29:11.842]             function(cond) {
[01:29:11.842]                 is_error <- inherits(cond, "error")
[01:29:11.842]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:11.842]                   NULL)
[01:29:11.842]                 if (is_error) {
[01:29:11.842]                   sessionInformation <- function() {
[01:29:11.842]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:11.842]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:11.842]                       search = base::search(), system = base::Sys.info())
[01:29:11.842]                   }
[01:29:11.842]                   ...future.conditions[[length(...future.conditions) + 
[01:29:11.842]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:11.842]                     cond$call), session = sessionInformation(), 
[01:29:11.842]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:11.842]                   signalCondition(cond)
[01:29:11.842]                 }
[01:29:11.842]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:11.842]                 "immediateCondition"))) {
[01:29:11.842]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:11.842]                   ...future.conditions[[length(...future.conditions) + 
[01:29:11.842]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:11.842]                   if (TRUE && !signal) {
[01:29:11.842]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:11.842]                     {
[01:29:11.842]                       inherits <- base::inherits
[01:29:11.842]                       invokeRestart <- base::invokeRestart
[01:29:11.842]                       is.null <- base::is.null
[01:29:11.842]                       muffled <- FALSE
[01:29:11.842]                       if (inherits(cond, "message")) {
[01:29:11.842]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:11.842]                         if (muffled) 
[01:29:11.842]                           invokeRestart("muffleMessage")
[01:29:11.842]                       }
[01:29:11.842]                       else if (inherits(cond, "warning")) {
[01:29:11.842]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:11.842]                         if (muffled) 
[01:29:11.842]                           invokeRestart("muffleWarning")
[01:29:11.842]                       }
[01:29:11.842]                       else if (inherits(cond, "condition")) {
[01:29:11.842]                         if (!is.null(pattern)) {
[01:29:11.842]                           computeRestarts <- base::computeRestarts
[01:29:11.842]                           grepl <- base::grepl
[01:29:11.842]                           restarts <- computeRestarts(cond)
[01:29:11.842]                           for (restart in restarts) {
[01:29:11.842]                             name <- restart$name
[01:29:11.842]                             if (is.null(name)) 
[01:29:11.842]                               next
[01:29:11.842]                             if (!grepl(pattern, name)) 
[01:29:11.842]                               next
[01:29:11.842]                             invokeRestart(restart)
[01:29:11.842]                             muffled <- TRUE
[01:29:11.842]                             break
[01:29:11.842]                           }
[01:29:11.842]                         }
[01:29:11.842]                       }
[01:29:11.842]                       invisible(muffled)
[01:29:11.842]                     }
[01:29:11.842]                     muffleCondition(cond, pattern = "^muffle")
[01:29:11.842]                   }
[01:29:11.842]                 }
[01:29:11.842]                 else {
[01:29:11.842]                   if (TRUE) {
[01:29:11.842]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:11.842]                     {
[01:29:11.842]                       inherits <- base::inherits
[01:29:11.842]                       invokeRestart <- base::invokeRestart
[01:29:11.842]                       is.null <- base::is.null
[01:29:11.842]                       muffled <- FALSE
[01:29:11.842]                       if (inherits(cond, "message")) {
[01:29:11.842]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:11.842]                         if (muffled) 
[01:29:11.842]                           invokeRestart("muffleMessage")
[01:29:11.842]                       }
[01:29:11.842]                       else if (inherits(cond, "warning")) {
[01:29:11.842]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:11.842]                         if (muffled) 
[01:29:11.842]                           invokeRestart("muffleWarning")
[01:29:11.842]                       }
[01:29:11.842]                       else if (inherits(cond, "condition")) {
[01:29:11.842]                         if (!is.null(pattern)) {
[01:29:11.842]                           computeRestarts <- base::computeRestarts
[01:29:11.842]                           grepl <- base::grepl
[01:29:11.842]                           restarts <- computeRestarts(cond)
[01:29:11.842]                           for (restart in restarts) {
[01:29:11.842]                             name <- restart$name
[01:29:11.842]                             if (is.null(name)) 
[01:29:11.842]                               next
[01:29:11.842]                             if (!grepl(pattern, name)) 
[01:29:11.842]                               next
[01:29:11.842]                             invokeRestart(restart)
[01:29:11.842]                             muffled <- TRUE
[01:29:11.842]                             break
[01:29:11.842]                           }
[01:29:11.842]                         }
[01:29:11.842]                       }
[01:29:11.842]                       invisible(muffled)
[01:29:11.842]                     }
[01:29:11.842]                     muffleCondition(cond, pattern = "^muffle")
[01:29:11.842]                   }
[01:29:11.842]                 }
[01:29:11.842]             }
[01:29:11.842]         }))
[01:29:11.842]     }, error = function(ex) {
[01:29:11.842]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:11.842]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:11.842]                 ...future.rng), started = ...future.startTime, 
[01:29:11.842]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:11.842]             version = "1.8"), class = "FutureResult")
[01:29:11.842]     }, finally = {
[01:29:11.842]         if (!identical(...future.workdir, getwd())) 
[01:29:11.842]             setwd(...future.workdir)
[01:29:11.842]         {
[01:29:11.842]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:11.842]                 ...future.oldOptions$nwarnings <- NULL
[01:29:11.842]             }
[01:29:11.842]             base::options(...future.oldOptions)
[01:29:11.842]             if (.Platform$OS.type == "windows") {
[01:29:11.842]                 old_names <- names(...future.oldEnvVars)
[01:29:11.842]                 envs <- base::Sys.getenv()
[01:29:11.842]                 names <- names(envs)
[01:29:11.842]                 common <- intersect(names, old_names)
[01:29:11.842]                 added <- setdiff(names, old_names)
[01:29:11.842]                 removed <- setdiff(old_names, names)
[01:29:11.842]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:11.842]                   envs[common]]
[01:29:11.842]                 NAMES <- toupper(changed)
[01:29:11.842]                 args <- list()
[01:29:11.842]                 for (kk in seq_along(NAMES)) {
[01:29:11.842]                   name <- changed[[kk]]
[01:29:11.842]                   NAME <- NAMES[[kk]]
[01:29:11.842]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:11.842]                     next
[01:29:11.842]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:11.842]                 }
[01:29:11.842]                 NAMES <- toupper(added)
[01:29:11.842]                 for (kk in seq_along(NAMES)) {
[01:29:11.842]                   name <- added[[kk]]
[01:29:11.842]                   NAME <- NAMES[[kk]]
[01:29:11.842]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:11.842]                     next
[01:29:11.842]                   args[[name]] <- ""
[01:29:11.842]                 }
[01:29:11.842]                 NAMES <- toupper(removed)
[01:29:11.842]                 for (kk in seq_along(NAMES)) {
[01:29:11.842]                   name <- removed[[kk]]
[01:29:11.842]                   NAME <- NAMES[[kk]]
[01:29:11.842]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:11.842]                     next
[01:29:11.842]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:11.842]                 }
[01:29:11.842]                 if (length(args) > 0) 
[01:29:11.842]                   base::do.call(base::Sys.setenv, args = args)
[01:29:11.842]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:11.842]             }
[01:29:11.842]             else {
[01:29:11.842]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:11.842]             }
[01:29:11.842]             {
[01:29:11.842]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:11.842]                   0L) {
[01:29:11.842]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:11.842]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:11.842]                   base::options(opts)
[01:29:11.842]                 }
[01:29:11.842]                 {
[01:29:11.842]                   {
[01:29:11.842]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:11.842]                     NULL
[01:29:11.842]                   }
[01:29:11.842]                   options(future.plan = NULL)
[01:29:11.842]                   if (is.na(NA_character_)) 
[01:29:11.842]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:11.842]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:11.842]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:11.842]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:11.842]                     envir = parent.frame()) 
[01:29:11.842]                   {
[01:29:11.842]                     if (is.function(workers)) 
[01:29:11.842]                       workers <- workers()
[01:29:11.842]                     workers <- structure(as.integer(workers), 
[01:29:11.842]                       class = class(workers))
[01:29:11.842]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:11.842]                       workers >= 1)
[01:29:11.842]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:11.842]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:11.842]                     }
[01:29:11.842]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:11.842]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:11.842]                       envir = envir)
[01:29:11.842]                     if (!future$lazy) 
[01:29:11.842]                       future <- run(future)
[01:29:11.842]                     invisible(future)
[01:29:11.842]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:11.842]                 }
[01:29:11.842]             }
[01:29:11.842]         }
[01:29:11.842]     })
[01:29:11.842]     if (TRUE) {
[01:29:11.842]         base::sink(type = "output", split = FALSE)
[01:29:11.842]         if (TRUE) {
[01:29:11.842]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:11.842]         }
[01:29:11.842]         else {
[01:29:11.842]             ...future.result["stdout"] <- base::list(NULL)
[01:29:11.842]         }
[01:29:11.842]         base::close(...future.stdout)
[01:29:11.842]         ...future.stdout <- NULL
[01:29:11.842]     }
[01:29:11.842]     ...future.result$conditions <- ...future.conditions
[01:29:11.842]     ...future.result$finished <- base::Sys.time()
[01:29:11.842]     ...future.result
[01:29:11.842] }
[01:29:11.849] MultisessionFuture started
[01:29:11.849] - Launch lazy future ... done
[01:29:11.849] run() for 'MultisessionFuture' ... done
[01:29:11.850] resolve() on list ...
[01:29:11.850]  recursive: 0
[01:29:11.850]  length: 3
[01:29:11.850]  elements: 'a', 'b', ''
[01:29:11.850] run() for 'Future' ...
[01:29:11.851] - state: 'created'
[01:29:11.851] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:11.865] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:11.865] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:11.865]   - Field: 'node'
[01:29:11.866]   - Field: 'label'
[01:29:11.866]   - Field: 'local'
[01:29:11.866]   - Field: 'owner'
[01:29:11.866]   - Field: 'envir'
[01:29:11.866]   - Field: 'workers'
[01:29:11.867]   - Field: 'packages'
[01:29:11.867]   - Field: 'gc'
[01:29:11.867]   - Field: 'conditions'
[01:29:11.867]   - Field: 'persistent'
[01:29:11.867]   - Field: 'expr'
[01:29:11.867]   - Field: 'uuid'
[01:29:11.868]   - Field: 'seed'
[01:29:11.868]   - Field: 'version'
[01:29:11.868]   - Field: 'result'
[01:29:11.868]   - Field: 'asynchronous'
[01:29:11.868]   - Field: 'calls'
[01:29:11.869]   - Field: 'globals'
[01:29:11.869]   - Field: 'stdout'
[01:29:11.869]   - Field: 'earlySignal'
[01:29:11.869]   - Field: 'lazy'
[01:29:11.869]   - Field: 'state'
[01:29:11.869] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:11.870] - Launch lazy future ...
[01:29:11.870] Packages needed by the future expression (n = 0): <none>
[01:29:11.870] Packages needed by future strategies (n = 0): <none>
[01:29:11.871] {
[01:29:11.871]     {
[01:29:11.871]         {
[01:29:11.871]             ...future.startTime <- base::Sys.time()
[01:29:11.871]             {
[01:29:11.871]                 {
[01:29:11.871]                   {
[01:29:11.871]                     {
[01:29:11.871]                       base::local({
[01:29:11.871]                         has_future <- base::requireNamespace("future", 
[01:29:11.871]                           quietly = TRUE)
[01:29:11.871]                         if (has_future) {
[01:29:11.871]                           ns <- base::getNamespace("future")
[01:29:11.871]                           version <- ns[[".package"]][["version"]]
[01:29:11.871]                           if (is.null(version)) 
[01:29:11.871]                             version <- utils::packageVersion("future")
[01:29:11.871]                         }
[01:29:11.871]                         else {
[01:29:11.871]                           version <- NULL
[01:29:11.871]                         }
[01:29:11.871]                         if (!has_future || version < "1.8.0") {
[01:29:11.871]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:11.871]                             "", base::R.version$version.string), 
[01:29:11.871]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:11.871]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:11.871]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:11.871]                               "release", "version")], collapse = " "), 
[01:29:11.871]                             hostname = base::Sys.info()[["nodename"]])
[01:29:11.871]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:11.871]                             info)
[01:29:11.871]                           info <- base::paste(info, collapse = "; ")
[01:29:11.871]                           if (!has_future) {
[01:29:11.871]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:11.871]                               info)
[01:29:11.871]                           }
[01:29:11.871]                           else {
[01:29:11.871]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:11.871]                               info, version)
[01:29:11.871]                           }
[01:29:11.871]                           base::stop(msg)
[01:29:11.871]                         }
[01:29:11.871]                       })
[01:29:11.871]                     }
[01:29:11.871]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:11.871]                     base::options(mc.cores = 1L)
[01:29:11.871]                   }
[01:29:11.871]                   options(future.plan = NULL)
[01:29:11.871]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:11.871]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:11.871]                 }
[01:29:11.871]                 ...future.workdir <- getwd()
[01:29:11.871]             }
[01:29:11.871]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:11.871]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:11.871]         }
[01:29:11.871]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:11.871]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:11.871]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:11.871]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:11.871]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:11.871]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:11.871]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:11.871]             base::names(...future.oldOptions))
[01:29:11.871]     }
[01:29:11.871]     if (FALSE) {
[01:29:11.871]     }
[01:29:11.871]     else {
[01:29:11.871]         if (TRUE) {
[01:29:11.871]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:11.871]                 open = "w")
[01:29:11.871]         }
[01:29:11.871]         else {
[01:29:11.871]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:11.871]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:11.871]         }
[01:29:11.871]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:11.871]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:11.871]             base::sink(type = "output", split = FALSE)
[01:29:11.871]             base::close(...future.stdout)
[01:29:11.871]         }, add = TRUE)
[01:29:11.871]     }
[01:29:11.871]     ...future.frame <- base::sys.nframe()
[01:29:11.871]     ...future.conditions <- base::list()
[01:29:11.871]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:11.871]     if (FALSE) {
[01:29:11.871]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:11.871]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:11.871]     }
[01:29:11.871]     ...future.result <- base::tryCatch({
[01:29:11.871]         base::withCallingHandlers({
[01:29:11.871]             ...future.value <- base::withVisible(base::local({
[01:29:11.871]                 ...future.makeSendCondition <- base::local({
[01:29:11.871]                   sendCondition <- NULL
[01:29:11.871]                   function(frame = 1L) {
[01:29:11.871]                     if (is.function(sendCondition)) 
[01:29:11.871]                       return(sendCondition)
[01:29:11.871]                     ns <- getNamespace("parallel")
[01:29:11.871]                     if (exists("sendData", mode = "function", 
[01:29:11.871]                       envir = ns)) {
[01:29:11.871]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:11.871]                         envir = ns)
[01:29:11.871]                       envir <- sys.frame(frame)
[01:29:11.871]                       master <- NULL
[01:29:11.871]                       while (!identical(envir, .GlobalEnv) && 
[01:29:11.871]                         !identical(envir, emptyenv())) {
[01:29:11.871]                         if (exists("master", mode = "list", envir = envir, 
[01:29:11.871]                           inherits = FALSE)) {
[01:29:11.871]                           master <- get("master", mode = "list", 
[01:29:11.871]                             envir = envir, inherits = FALSE)
[01:29:11.871]                           if (inherits(master, c("SOCKnode", 
[01:29:11.871]                             "SOCK0node"))) {
[01:29:11.871]                             sendCondition <<- function(cond) {
[01:29:11.871]                               data <- list(type = "VALUE", value = cond, 
[01:29:11.871]                                 success = TRUE)
[01:29:11.871]                               parallel_sendData(master, data)
[01:29:11.871]                             }
[01:29:11.871]                             return(sendCondition)
[01:29:11.871]                           }
[01:29:11.871]                         }
[01:29:11.871]                         frame <- frame + 1L
[01:29:11.871]                         envir <- sys.frame(frame)
[01:29:11.871]                       }
[01:29:11.871]                     }
[01:29:11.871]                     sendCondition <<- function(cond) NULL
[01:29:11.871]                   }
[01:29:11.871]                 })
[01:29:11.871]                 withCallingHandlers({
[01:29:11.871]                   1
[01:29:11.871]                 }, immediateCondition = function(cond) {
[01:29:11.871]                   sendCondition <- ...future.makeSendCondition()
[01:29:11.871]                   sendCondition(cond)
[01:29:11.871]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:11.871]                   {
[01:29:11.871]                     inherits <- base::inherits
[01:29:11.871]                     invokeRestart <- base::invokeRestart
[01:29:11.871]                     is.null <- base::is.null
[01:29:11.871]                     muffled <- FALSE
[01:29:11.871]                     if (inherits(cond, "message")) {
[01:29:11.871]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:11.871]                       if (muffled) 
[01:29:11.871]                         invokeRestart("muffleMessage")
[01:29:11.871]                     }
[01:29:11.871]                     else if (inherits(cond, "warning")) {
[01:29:11.871]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:11.871]                       if (muffled) 
[01:29:11.871]                         invokeRestart("muffleWarning")
[01:29:11.871]                     }
[01:29:11.871]                     else if (inherits(cond, "condition")) {
[01:29:11.871]                       if (!is.null(pattern)) {
[01:29:11.871]                         computeRestarts <- base::computeRestarts
[01:29:11.871]                         grepl <- base::grepl
[01:29:11.871]                         restarts <- computeRestarts(cond)
[01:29:11.871]                         for (restart in restarts) {
[01:29:11.871]                           name <- restart$name
[01:29:11.871]                           if (is.null(name)) 
[01:29:11.871]                             next
[01:29:11.871]                           if (!grepl(pattern, name)) 
[01:29:11.871]                             next
[01:29:11.871]                           invokeRestart(restart)
[01:29:11.871]                           muffled <- TRUE
[01:29:11.871]                           break
[01:29:11.871]                         }
[01:29:11.871]                       }
[01:29:11.871]                     }
[01:29:11.871]                     invisible(muffled)
[01:29:11.871]                   }
[01:29:11.871]                   muffleCondition(cond)
[01:29:11.871]                 })
[01:29:11.871]             }))
[01:29:11.871]             future::FutureResult(value = ...future.value$value, 
[01:29:11.871]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:11.871]                   ...future.rng), globalenv = if (FALSE) 
[01:29:11.871]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:11.871]                     ...future.globalenv.names))
[01:29:11.871]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:11.871]         }, condition = base::local({
[01:29:11.871]             c <- base::c
[01:29:11.871]             inherits <- base::inherits
[01:29:11.871]             invokeRestart <- base::invokeRestart
[01:29:11.871]             length <- base::length
[01:29:11.871]             list <- base::list
[01:29:11.871]             seq.int <- base::seq.int
[01:29:11.871]             signalCondition <- base::signalCondition
[01:29:11.871]             sys.calls <- base::sys.calls
[01:29:11.871]             `[[` <- base::`[[`
[01:29:11.871]             `+` <- base::`+`
[01:29:11.871]             `<<-` <- base::`<<-`
[01:29:11.871]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:11.871]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:11.871]                   3L)]
[01:29:11.871]             }
[01:29:11.871]             function(cond) {
[01:29:11.871]                 is_error <- inherits(cond, "error")
[01:29:11.871]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:11.871]                   NULL)
[01:29:11.871]                 if (is_error) {
[01:29:11.871]                   sessionInformation <- function() {
[01:29:11.871]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:11.871]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:11.871]                       search = base::search(), system = base::Sys.info())
[01:29:11.871]                   }
[01:29:11.871]                   ...future.conditions[[length(...future.conditions) + 
[01:29:11.871]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:11.871]                     cond$call), session = sessionInformation(), 
[01:29:11.871]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:11.871]                   signalCondition(cond)
[01:29:11.871]                 }
[01:29:11.871]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:11.871]                 "immediateCondition"))) {
[01:29:11.871]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:11.871]                   ...future.conditions[[length(...future.conditions) + 
[01:29:11.871]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:11.871]                   if (TRUE && !signal) {
[01:29:11.871]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:11.871]                     {
[01:29:11.871]                       inherits <- base::inherits
[01:29:11.871]                       invokeRestart <- base::invokeRestart
[01:29:11.871]                       is.null <- base::is.null
[01:29:11.871]                       muffled <- FALSE
[01:29:11.871]                       if (inherits(cond, "message")) {
[01:29:11.871]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:11.871]                         if (muffled) 
[01:29:11.871]                           invokeRestart("muffleMessage")
[01:29:11.871]                       }
[01:29:11.871]                       else if (inherits(cond, "warning")) {
[01:29:11.871]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:11.871]                         if (muffled) 
[01:29:11.871]                           invokeRestart("muffleWarning")
[01:29:11.871]                       }
[01:29:11.871]                       else if (inherits(cond, "condition")) {
[01:29:11.871]                         if (!is.null(pattern)) {
[01:29:11.871]                           computeRestarts <- base::computeRestarts
[01:29:11.871]                           grepl <- base::grepl
[01:29:11.871]                           restarts <- computeRestarts(cond)
[01:29:11.871]                           for (restart in restarts) {
[01:29:11.871]                             name <- restart$name
[01:29:11.871]                             if (is.null(name)) 
[01:29:11.871]                               next
[01:29:11.871]                             if (!grepl(pattern, name)) 
[01:29:11.871]                               next
[01:29:11.871]                             invokeRestart(restart)
[01:29:11.871]                             muffled <- TRUE
[01:29:11.871]                             break
[01:29:11.871]                           }
[01:29:11.871]                         }
[01:29:11.871]                       }
[01:29:11.871]                       invisible(muffled)
[01:29:11.871]                     }
[01:29:11.871]                     muffleCondition(cond, pattern = "^muffle")
[01:29:11.871]                   }
[01:29:11.871]                 }
[01:29:11.871]                 else {
[01:29:11.871]                   if (TRUE) {
[01:29:11.871]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:11.871]                     {
[01:29:11.871]                       inherits <- base::inherits
[01:29:11.871]                       invokeRestart <- base::invokeRestart
[01:29:11.871]                       is.null <- base::is.null
[01:29:11.871]                       muffled <- FALSE
[01:29:11.871]                       if (inherits(cond, "message")) {
[01:29:11.871]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:11.871]                         if (muffled) 
[01:29:11.871]                           invokeRestart("muffleMessage")
[01:29:11.871]                       }
[01:29:11.871]                       else if (inherits(cond, "warning")) {
[01:29:11.871]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:11.871]                         if (muffled) 
[01:29:11.871]                           invokeRestart("muffleWarning")
[01:29:11.871]                       }
[01:29:11.871]                       else if (inherits(cond, "condition")) {
[01:29:11.871]                         if (!is.null(pattern)) {
[01:29:11.871]                           computeRestarts <- base::computeRestarts
[01:29:11.871]                           grepl <- base::grepl
[01:29:11.871]                           restarts <- computeRestarts(cond)
[01:29:11.871]                           for (restart in restarts) {
[01:29:11.871]                             name <- restart$name
[01:29:11.871]                             if (is.null(name)) 
[01:29:11.871]                               next
[01:29:11.871]                             if (!grepl(pattern, name)) 
[01:29:11.871]                               next
[01:29:11.871]                             invokeRestart(restart)
[01:29:11.871]                             muffled <- TRUE
[01:29:11.871]                             break
[01:29:11.871]                           }
[01:29:11.871]                         }
[01:29:11.871]                       }
[01:29:11.871]                       invisible(muffled)
[01:29:11.871]                     }
[01:29:11.871]                     muffleCondition(cond, pattern = "^muffle")
[01:29:11.871]                   }
[01:29:11.871]                 }
[01:29:11.871]             }
[01:29:11.871]         }))
[01:29:11.871]     }, error = function(ex) {
[01:29:11.871]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:11.871]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:11.871]                 ...future.rng), started = ...future.startTime, 
[01:29:11.871]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:11.871]             version = "1.8"), class = "FutureResult")
[01:29:11.871]     }, finally = {
[01:29:11.871]         if (!identical(...future.workdir, getwd())) 
[01:29:11.871]             setwd(...future.workdir)
[01:29:11.871]         {
[01:29:11.871]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:11.871]                 ...future.oldOptions$nwarnings <- NULL
[01:29:11.871]             }
[01:29:11.871]             base::options(...future.oldOptions)
[01:29:11.871]             if (.Platform$OS.type == "windows") {
[01:29:11.871]                 old_names <- names(...future.oldEnvVars)
[01:29:11.871]                 envs <- base::Sys.getenv()
[01:29:11.871]                 names <- names(envs)
[01:29:11.871]                 common <- intersect(names, old_names)
[01:29:11.871]                 added <- setdiff(names, old_names)
[01:29:11.871]                 removed <- setdiff(old_names, names)
[01:29:11.871]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:11.871]                   envs[common]]
[01:29:11.871]                 NAMES <- toupper(changed)
[01:29:11.871]                 args <- list()
[01:29:11.871]                 for (kk in seq_along(NAMES)) {
[01:29:11.871]                   name <- changed[[kk]]
[01:29:11.871]                   NAME <- NAMES[[kk]]
[01:29:11.871]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:11.871]                     next
[01:29:11.871]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:11.871]                 }
[01:29:11.871]                 NAMES <- toupper(added)
[01:29:11.871]                 for (kk in seq_along(NAMES)) {
[01:29:11.871]                   name <- added[[kk]]
[01:29:11.871]                   NAME <- NAMES[[kk]]
[01:29:11.871]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:11.871]                     next
[01:29:11.871]                   args[[name]] <- ""
[01:29:11.871]                 }
[01:29:11.871]                 NAMES <- toupper(removed)
[01:29:11.871]                 for (kk in seq_along(NAMES)) {
[01:29:11.871]                   name <- removed[[kk]]
[01:29:11.871]                   NAME <- NAMES[[kk]]
[01:29:11.871]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:11.871]                     next
[01:29:11.871]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:11.871]                 }
[01:29:11.871]                 if (length(args) > 0) 
[01:29:11.871]                   base::do.call(base::Sys.setenv, args = args)
[01:29:11.871]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:11.871]             }
[01:29:11.871]             else {
[01:29:11.871]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:11.871]             }
[01:29:11.871]             {
[01:29:11.871]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:11.871]                   0L) {
[01:29:11.871]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:11.871]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:11.871]                   base::options(opts)
[01:29:11.871]                 }
[01:29:11.871]                 {
[01:29:11.871]                   {
[01:29:11.871]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:11.871]                     NULL
[01:29:11.871]                   }
[01:29:11.871]                   options(future.plan = NULL)
[01:29:11.871]                   if (is.na(NA_character_)) 
[01:29:11.871]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:11.871]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:11.871]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:11.871]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:11.871]                     envir = parent.frame()) 
[01:29:11.871]                   {
[01:29:11.871]                     if (is.function(workers)) 
[01:29:11.871]                       workers <- workers()
[01:29:11.871]                     workers <- structure(as.integer(workers), 
[01:29:11.871]                       class = class(workers))
[01:29:11.871]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:11.871]                       workers >= 1)
[01:29:11.871]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:11.871]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:11.871]                     }
[01:29:11.871]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:11.871]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:11.871]                       envir = envir)
[01:29:11.871]                     if (!future$lazy) 
[01:29:11.871]                       future <- run(future)
[01:29:11.871]                     invisible(future)
[01:29:11.871]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:11.871]                 }
[01:29:11.871]             }
[01:29:11.871]         }
[01:29:11.871]     })
[01:29:11.871]     if (TRUE) {
[01:29:11.871]         base::sink(type = "output", split = FALSE)
[01:29:11.871]         if (TRUE) {
[01:29:11.871]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:11.871]         }
[01:29:11.871]         else {
[01:29:11.871]             ...future.result["stdout"] <- base::list(NULL)
[01:29:11.871]         }
[01:29:11.871]         base::close(...future.stdout)
[01:29:11.871]         ...future.stdout <- NULL
[01:29:11.871]     }
[01:29:11.871]     ...future.result$conditions <- ...future.conditions
[01:29:11.871]     ...future.result$finished <- base::Sys.time()
[01:29:11.871]     ...future.result
[01:29:11.871] }
[01:29:11.877] MultisessionFuture started
[01:29:11.878] - Launch lazy future ... done
[01:29:11.878] run() for 'MultisessionFuture' ... done
[01:29:11.896] receiveMessageFromWorker() for ClusterFuture ...
[01:29:11.897] - Validating connection of MultisessionFuture
[01:29:11.897] - received message: FutureResult
[01:29:11.897] - Received FutureResult
[01:29:11.897] - Erased future from FutureRegistry
[01:29:11.897] result() for ClusterFuture ...
[01:29:11.898] - result already collected: FutureResult
[01:29:11.898] result() for ClusterFuture ... done
[01:29:11.898] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:11.898] Future #1
[01:29:11.898]  length: 2 (resolved future 1)
[01:29:11.899] receiveMessageFromWorker() for ClusterFuture ...
[01:29:11.899] - Validating connection of MultisessionFuture
[01:29:11.899] - received message: FutureResult
[01:29:11.900] - Received FutureResult
[01:29:11.900] - Erased future from FutureRegistry
[01:29:11.900] result() for ClusterFuture ...
[01:29:11.900] - result already collected: FutureResult
[01:29:11.900] result() for ClusterFuture ... done
[01:29:11.900] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:11.901] Future #2
[01:29:11.901]  length: 1 (resolved future 2)
[01:29:11.901]  length: 0 (resolved future 3)
[01:29:11.901] resolve() on list ... DONE
[01:29:11.901] getGlobalsAndPackages() ...
[01:29:11.902] Searching for globals...
[01:29:11.902] 
[01:29:11.902] Searching for globals ... DONE
[01:29:11.902] - globals: [0] <none>
[01:29:11.903] getGlobalsAndPackages() ... DONE
[01:29:11.903] getGlobalsAndPackages() ...
[01:29:11.903] Searching for globals...
[01:29:11.904] 
[01:29:11.904] Searching for globals ... DONE
[01:29:11.904] - globals: [0] <none>
[01:29:11.904] getGlobalsAndPackages() ... DONE
[01:29:11.904] resolve() on list ...
[01:29:11.905]  recursive: 0
[01:29:11.905]  length: 3
[01:29:11.905]  elements: 'a', 'b', ''
[01:29:11.905] run() for 'Future' ...
[01:29:11.905] - state: 'created'
[01:29:11.906] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:11.921] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:11.921] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:11.921]   - Field: 'node'
[01:29:11.921]   - Field: 'label'
[01:29:11.922]   - Field: 'local'
[01:29:11.922]   - Field: 'owner'
[01:29:11.922]   - Field: 'envir'
[01:29:11.922]   - Field: 'workers'
[01:29:11.922]   - Field: 'packages'
[01:29:11.923]   - Field: 'gc'
[01:29:11.923]   - Field: 'conditions'
[01:29:11.923]   - Field: 'persistent'
[01:29:11.923]   - Field: 'expr'
[01:29:11.923]   - Field: 'uuid'
[01:29:11.924]   - Field: 'seed'
[01:29:11.924]   - Field: 'version'
[01:29:11.924]   - Field: 'result'
[01:29:11.924]   - Field: 'asynchronous'
[01:29:11.924]   - Field: 'calls'
[01:29:11.925]   - Field: 'globals'
[01:29:11.925]   - Field: 'stdout'
[01:29:11.925]   - Field: 'earlySignal'
[01:29:11.925]   - Field: 'lazy'
[01:29:11.925]   - Field: 'state'
[01:29:11.925] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:11.926] - Launch lazy future ...
[01:29:11.926] Packages needed by the future expression (n = 0): <none>
[01:29:11.926] Packages needed by future strategies (n = 0): <none>
[01:29:11.927] {
[01:29:11.927]     {
[01:29:11.927]         {
[01:29:11.927]             ...future.startTime <- base::Sys.time()
[01:29:11.927]             {
[01:29:11.927]                 {
[01:29:11.927]                   {
[01:29:11.927]                     {
[01:29:11.927]                       base::local({
[01:29:11.927]                         has_future <- base::requireNamespace("future", 
[01:29:11.927]                           quietly = TRUE)
[01:29:11.927]                         if (has_future) {
[01:29:11.927]                           ns <- base::getNamespace("future")
[01:29:11.927]                           version <- ns[[".package"]][["version"]]
[01:29:11.927]                           if (is.null(version)) 
[01:29:11.927]                             version <- utils::packageVersion("future")
[01:29:11.927]                         }
[01:29:11.927]                         else {
[01:29:11.927]                           version <- NULL
[01:29:11.927]                         }
[01:29:11.927]                         if (!has_future || version < "1.8.0") {
[01:29:11.927]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:11.927]                             "", base::R.version$version.string), 
[01:29:11.927]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:11.927]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:11.927]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:11.927]                               "release", "version")], collapse = " "), 
[01:29:11.927]                             hostname = base::Sys.info()[["nodename"]])
[01:29:11.927]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:11.927]                             info)
[01:29:11.927]                           info <- base::paste(info, collapse = "; ")
[01:29:11.927]                           if (!has_future) {
[01:29:11.927]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:11.927]                               info)
[01:29:11.927]                           }
[01:29:11.927]                           else {
[01:29:11.927]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:11.927]                               info, version)
[01:29:11.927]                           }
[01:29:11.927]                           base::stop(msg)
[01:29:11.927]                         }
[01:29:11.927]                       })
[01:29:11.927]                     }
[01:29:11.927]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:11.927]                     base::options(mc.cores = 1L)
[01:29:11.927]                   }
[01:29:11.927]                   options(future.plan = NULL)
[01:29:11.927]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:11.927]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:11.927]                 }
[01:29:11.927]                 ...future.workdir <- getwd()
[01:29:11.927]             }
[01:29:11.927]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:11.927]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:11.927]         }
[01:29:11.927]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:11.927]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:11.927]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:11.927]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:11.927]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:11.927]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:11.927]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:11.927]             base::names(...future.oldOptions))
[01:29:11.927]     }
[01:29:11.927]     if (FALSE) {
[01:29:11.927]     }
[01:29:11.927]     else {
[01:29:11.927]         if (TRUE) {
[01:29:11.927]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:11.927]                 open = "w")
[01:29:11.927]         }
[01:29:11.927]         else {
[01:29:11.927]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:11.927]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:11.927]         }
[01:29:11.927]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:11.927]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:11.927]             base::sink(type = "output", split = FALSE)
[01:29:11.927]             base::close(...future.stdout)
[01:29:11.927]         }, add = TRUE)
[01:29:11.927]     }
[01:29:11.927]     ...future.frame <- base::sys.nframe()
[01:29:11.927]     ...future.conditions <- base::list()
[01:29:11.927]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:11.927]     if (FALSE) {
[01:29:11.927]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:11.927]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:11.927]     }
[01:29:11.927]     ...future.result <- base::tryCatch({
[01:29:11.927]         base::withCallingHandlers({
[01:29:11.927]             ...future.value <- base::withVisible(base::local({
[01:29:11.927]                 ...future.makeSendCondition <- base::local({
[01:29:11.927]                   sendCondition <- NULL
[01:29:11.927]                   function(frame = 1L) {
[01:29:11.927]                     if (is.function(sendCondition)) 
[01:29:11.927]                       return(sendCondition)
[01:29:11.927]                     ns <- getNamespace("parallel")
[01:29:11.927]                     if (exists("sendData", mode = "function", 
[01:29:11.927]                       envir = ns)) {
[01:29:11.927]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:11.927]                         envir = ns)
[01:29:11.927]                       envir <- sys.frame(frame)
[01:29:11.927]                       master <- NULL
[01:29:11.927]                       while (!identical(envir, .GlobalEnv) && 
[01:29:11.927]                         !identical(envir, emptyenv())) {
[01:29:11.927]                         if (exists("master", mode = "list", envir = envir, 
[01:29:11.927]                           inherits = FALSE)) {
[01:29:11.927]                           master <- get("master", mode = "list", 
[01:29:11.927]                             envir = envir, inherits = FALSE)
[01:29:11.927]                           if (inherits(master, c("SOCKnode", 
[01:29:11.927]                             "SOCK0node"))) {
[01:29:11.927]                             sendCondition <<- function(cond) {
[01:29:11.927]                               data <- list(type = "VALUE", value = cond, 
[01:29:11.927]                                 success = TRUE)
[01:29:11.927]                               parallel_sendData(master, data)
[01:29:11.927]                             }
[01:29:11.927]                             return(sendCondition)
[01:29:11.927]                           }
[01:29:11.927]                         }
[01:29:11.927]                         frame <- frame + 1L
[01:29:11.927]                         envir <- sys.frame(frame)
[01:29:11.927]                       }
[01:29:11.927]                     }
[01:29:11.927]                     sendCondition <<- function(cond) NULL
[01:29:11.927]                   }
[01:29:11.927]                 })
[01:29:11.927]                 withCallingHandlers({
[01:29:11.927]                   1
[01:29:11.927]                 }, immediateCondition = function(cond) {
[01:29:11.927]                   sendCondition <- ...future.makeSendCondition()
[01:29:11.927]                   sendCondition(cond)
[01:29:11.927]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:11.927]                   {
[01:29:11.927]                     inherits <- base::inherits
[01:29:11.927]                     invokeRestart <- base::invokeRestart
[01:29:11.927]                     is.null <- base::is.null
[01:29:11.927]                     muffled <- FALSE
[01:29:11.927]                     if (inherits(cond, "message")) {
[01:29:11.927]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:11.927]                       if (muffled) 
[01:29:11.927]                         invokeRestart("muffleMessage")
[01:29:11.927]                     }
[01:29:11.927]                     else if (inherits(cond, "warning")) {
[01:29:11.927]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:11.927]                       if (muffled) 
[01:29:11.927]                         invokeRestart("muffleWarning")
[01:29:11.927]                     }
[01:29:11.927]                     else if (inherits(cond, "condition")) {
[01:29:11.927]                       if (!is.null(pattern)) {
[01:29:11.927]                         computeRestarts <- base::computeRestarts
[01:29:11.927]                         grepl <- base::grepl
[01:29:11.927]                         restarts <- computeRestarts(cond)
[01:29:11.927]                         for (restart in restarts) {
[01:29:11.927]                           name <- restart$name
[01:29:11.927]                           if (is.null(name)) 
[01:29:11.927]                             next
[01:29:11.927]                           if (!grepl(pattern, name)) 
[01:29:11.927]                             next
[01:29:11.927]                           invokeRestart(restart)
[01:29:11.927]                           muffled <- TRUE
[01:29:11.927]                           break
[01:29:11.927]                         }
[01:29:11.927]                       }
[01:29:11.927]                     }
[01:29:11.927]                     invisible(muffled)
[01:29:11.927]                   }
[01:29:11.927]                   muffleCondition(cond)
[01:29:11.927]                 })
[01:29:11.927]             }))
[01:29:11.927]             future::FutureResult(value = ...future.value$value, 
[01:29:11.927]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:11.927]                   ...future.rng), globalenv = if (FALSE) 
[01:29:11.927]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:11.927]                     ...future.globalenv.names))
[01:29:11.927]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:11.927]         }, condition = base::local({
[01:29:11.927]             c <- base::c
[01:29:11.927]             inherits <- base::inherits
[01:29:11.927]             invokeRestart <- base::invokeRestart
[01:29:11.927]             length <- base::length
[01:29:11.927]             list <- base::list
[01:29:11.927]             seq.int <- base::seq.int
[01:29:11.927]             signalCondition <- base::signalCondition
[01:29:11.927]             sys.calls <- base::sys.calls
[01:29:11.927]             `[[` <- base::`[[`
[01:29:11.927]             `+` <- base::`+`
[01:29:11.927]             `<<-` <- base::`<<-`
[01:29:11.927]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:11.927]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:11.927]                   3L)]
[01:29:11.927]             }
[01:29:11.927]             function(cond) {
[01:29:11.927]                 is_error <- inherits(cond, "error")
[01:29:11.927]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:11.927]                   NULL)
[01:29:11.927]                 if (is_error) {
[01:29:11.927]                   sessionInformation <- function() {
[01:29:11.927]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:11.927]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:11.927]                       search = base::search(), system = base::Sys.info())
[01:29:11.927]                   }
[01:29:11.927]                   ...future.conditions[[length(...future.conditions) + 
[01:29:11.927]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:11.927]                     cond$call), session = sessionInformation(), 
[01:29:11.927]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:11.927]                   signalCondition(cond)
[01:29:11.927]                 }
[01:29:11.927]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:11.927]                 "immediateCondition"))) {
[01:29:11.927]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:11.927]                   ...future.conditions[[length(...future.conditions) + 
[01:29:11.927]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:11.927]                   if (TRUE && !signal) {
[01:29:11.927]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:11.927]                     {
[01:29:11.927]                       inherits <- base::inherits
[01:29:11.927]                       invokeRestart <- base::invokeRestart
[01:29:11.927]                       is.null <- base::is.null
[01:29:11.927]                       muffled <- FALSE
[01:29:11.927]                       if (inherits(cond, "message")) {
[01:29:11.927]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:11.927]                         if (muffled) 
[01:29:11.927]                           invokeRestart("muffleMessage")
[01:29:11.927]                       }
[01:29:11.927]                       else if (inherits(cond, "warning")) {
[01:29:11.927]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:11.927]                         if (muffled) 
[01:29:11.927]                           invokeRestart("muffleWarning")
[01:29:11.927]                       }
[01:29:11.927]                       else if (inherits(cond, "condition")) {
[01:29:11.927]                         if (!is.null(pattern)) {
[01:29:11.927]                           computeRestarts <- base::computeRestarts
[01:29:11.927]                           grepl <- base::grepl
[01:29:11.927]                           restarts <- computeRestarts(cond)
[01:29:11.927]                           for (restart in restarts) {
[01:29:11.927]                             name <- restart$name
[01:29:11.927]                             if (is.null(name)) 
[01:29:11.927]                               next
[01:29:11.927]                             if (!grepl(pattern, name)) 
[01:29:11.927]                               next
[01:29:11.927]                             invokeRestart(restart)
[01:29:11.927]                             muffled <- TRUE
[01:29:11.927]                             break
[01:29:11.927]                           }
[01:29:11.927]                         }
[01:29:11.927]                       }
[01:29:11.927]                       invisible(muffled)
[01:29:11.927]                     }
[01:29:11.927]                     muffleCondition(cond, pattern = "^muffle")
[01:29:11.927]                   }
[01:29:11.927]                 }
[01:29:11.927]                 else {
[01:29:11.927]                   if (TRUE) {
[01:29:11.927]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:11.927]                     {
[01:29:11.927]                       inherits <- base::inherits
[01:29:11.927]                       invokeRestart <- base::invokeRestart
[01:29:11.927]                       is.null <- base::is.null
[01:29:11.927]                       muffled <- FALSE
[01:29:11.927]                       if (inherits(cond, "message")) {
[01:29:11.927]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:11.927]                         if (muffled) 
[01:29:11.927]                           invokeRestart("muffleMessage")
[01:29:11.927]                       }
[01:29:11.927]                       else if (inherits(cond, "warning")) {
[01:29:11.927]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:11.927]                         if (muffled) 
[01:29:11.927]                           invokeRestart("muffleWarning")
[01:29:11.927]                       }
[01:29:11.927]                       else if (inherits(cond, "condition")) {
[01:29:11.927]                         if (!is.null(pattern)) {
[01:29:11.927]                           computeRestarts <- base::computeRestarts
[01:29:11.927]                           grepl <- base::grepl
[01:29:11.927]                           restarts <- computeRestarts(cond)
[01:29:11.927]                           for (restart in restarts) {
[01:29:11.927]                             name <- restart$name
[01:29:11.927]                             if (is.null(name)) 
[01:29:11.927]                               next
[01:29:11.927]                             if (!grepl(pattern, name)) 
[01:29:11.927]                               next
[01:29:11.927]                             invokeRestart(restart)
[01:29:11.927]                             muffled <- TRUE
[01:29:11.927]                             break
[01:29:11.927]                           }
[01:29:11.927]                         }
[01:29:11.927]                       }
[01:29:11.927]                       invisible(muffled)
[01:29:11.927]                     }
[01:29:11.927]                     muffleCondition(cond, pattern = "^muffle")
[01:29:11.927]                   }
[01:29:11.927]                 }
[01:29:11.927]             }
[01:29:11.927]         }))
[01:29:11.927]     }, error = function(ex) {
[01:29:11.927]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:11.927]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:11.927]                 ...future.rng), started = ...future.startTime, 
[01:29:11.927]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:11.927]             version = "1.8"), class = "FutureResult")
[01:29:11.927]     }, finally = {
[01:29:11.927]         if (!identical(...future.workdir, getwd())) 
[01:29:11.927]             setwd(...future.workdir)
[01:29:11.927]         {
[01:29:11.927]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:11.927]                 ...future.oldOptions$nwarnings <- NULL
[01:29:11.927]             }
[01:29:11.927]             base::options(...future.oldOptions)
[01:29:11.927]             if (.Platform$OS.type == "windows") {
[01:29:11.927]                 old_names <- names(...future.oldEnvVars)
[01:29:11.927]                 envs <- base::Sys.getenv()
[01:29:11.927]                 names <- names(envs)
[01:29:11.927]                 common <- intersect(names, old_names)
[01:29:11.927]                 added <- setdiff(names, old_names)
[01:29:11.927]                 removed <- setdiff(old_names, names)
[01:29:11.927]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:11.927]                   envs[common]]
[01:29:11.927]                 NAMES <- toupper(changed)
[01:29:11.927]                 args <- list()
[01:29:11.927]                 for (kk in seq_along(NAMES)) {
[01:29:11.927]                   name <- changed[[kk]]
[01:29:11.927]                   NAME <- NAMES[[kk]]
[01:29:11.927]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:11.927]                     next
[01:29:11.927]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:11.927]                 }
[01:29:11.927]                 NAMES <- toupper(added)
[01:29:11.927]                 for (kk in seq_along(NAMES)) {
[01:29:11.927]                   name <- added[[kk]]
[01:29:11.927]                   NAME <- NAMES[[kk]]
[01:29:11.927]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:11.927]                     next
[01:29:11.927]                   args[[name]] <- ""
[01:29:11.927]                 }
[01:29:11.927]                 NAMES <- toupper(removed)
[01:29:11.927]                 for (kk in seq_along(NAMES)) {
[01:29:11.927]                   name <- removed[[kk]]
[01:29:11.927]                   NAME <- NAMES[[kk]]
[01:29:11.927]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:11.927]                     next
[01:29:11.927]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:11.927]                 }
[01:29:11.927]                 if (length(args) > 0) 
[01:29:11.927]                   base::do.call(base::Sys.setenv, args = args)
[01:29:11.927]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:11.927]             }
[01:29:11.927]             else {
[01:29:11.927]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:11.927]             }
[01:29:11.927]             {
[01:29:11.927]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:11.927]                   0L) {
[01:29:11.927]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:11.927]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:11.927]                   base::options(opts)
[01:29:11.927]                 }
[01:29:11.927]                 {
[01:29:11.927]                   {
[01:29:11.927]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:11.927]                     NULL
[01:29:11.927]                   }
[01:29:11.927]                   options(future.plan = NULL)
[01:29:11.927]                   if (is.na(NA_character_)) 
[01:29:11.927]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:11.927]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:11.927]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:11.927]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:11.927]                     envir = parent.frame()) 
[01:29:11.927]                   {
[01:29:11.927]                     if (is.function(workers)) 
[01:29:11.927]                       workers <- workers()
[01:29:11.927]                     workers <- structure(as.integer(workers), 
[01:29:11.927]                       class = class(workers))
[01:29:11.927]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:11.927]                       workers >= 1)
[01:29:11.927]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:11.927]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:11.927]                     }
[01:29:11.927]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:11.927]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:11.927]                       envir = envir)
[01:29:11.927]                     if (!future$lazy) 
[01:29:11.927]                       future <- run(future)
[01:29:11.927]                     invisible(future)
[01:29:11.927]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:11.927]                 }
[01:29:11.927]             }
[01:29:11.927]         }
[01:29:11.927]     })
[01:29:11.927]     if (TRUE) {
[01:29:11.927]         base::sink(type = "output", split = FALSE)
[01:29:11.927]         if (TRUE) {
[01:29:11.927]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:11.927]         }
[01:29:11.927]         else {
[01:29:11.927]             ...future.result["stdout"] <- base::list(NULL)
[01:29:11.927]         }
[01:29:11.927]         base::close(...future.stdout)
[01:29:11.927]         ...future.stdout <- NULL
[01:29:11.927]     }
[01:29:11.927]     ...future.result$conditions <- ...future.conditions
[01:29:11.927]     ...future.result$finished <- base::Sys.time()
[01:29:11.927]     ...future.result
[01:29:11.927] }
[01:29:11.934] MultisessionFuture started
[01:29:11.934] - Launch lazy future ... done
[01:29:11.934] run() for 'MultisessionFuture' ... done
[01:29:11.954] receiveMessageFromWorker() for ClusterFuture ...
[01:29:11.954] - Validating connection of MultisessionFuture
[01:29:11.954] - received message: FutureResult
[01:29:11.954] - Received FutureResult
[01:29:11.955] - Erased future from FutureRegistry
[01:29:11.955] result() for ClusterFuture ...
[01:29:11.955] - result already collected: FutureResult
[01:29:11.955] result() for ClusterFuture ... done
[01:29:11.955] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:11.955] Future #1
[01:29:11.956]  length: 2 (resolved future 1)
[01:29:11.956] run() for 'Future' ...
[01:29:11.956] - state: 'created'
[01:29:11.956] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:11.971] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:11.971] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:11.971]   - Field: 'node'
[01:29:11.972]   - Field: 'label'
[01:29:11.972]   - Field: 'local'
[01:29:11.972]   - Field: 'owner'
[01:29:11.972]   - Field: 'envir'
[01:29:11.972]   - Field: 'workers'
[01:29:11.973]   - Field: 'packages'
[01:29:11.973]   - Field: 'gc'
[01:29:11.973]   - Field: 'conditions'
[01:29:11.973]   - Field: 'persistent'
[01:29:11.973]   - Field: 'expr'
[01:29:11.973]   - Field: 'uuid'
[01:29:11.974]   - Field: 'seed'
[01:29:11.974]   - Field: 'version'
[01:29:11.974]   - Field: 'result'
[01:29:11.974]   - Field: 'asynchronous'
[01:29:11.974]   - Field: 'calls'
[01:29:11.975]   - Field: 'globals'
[01:29:11.975]   - Field: 'stdout'
[01:29:11.975]   - Field: 'earlySignal'
[01:29:11.975]   - Field: 'lazy'
[01:29:11.975]   - Field: 'state'
[01:29:11.975] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:11.976] - Launch lazy future ...
[01:29:11.976] Packages needed by the future expression (n = 0): <none>
[01:29:11.976] Packages needed by future strategies (n = 0): <none>
[01:29:11.977] {
[01:29:11.977]     {
[01:29:11.977]         {
[01:29:11.977]             ...future.startTime <- base::Sys.time()
[01:29:11.977]             {
[01:29:11.977]                 {
[01:29:11.977]                   {
[01:29:11.977]                     {
[01:29:11.977]                       base::local({
[01:29:11.977]                         has_future <- base::requireNamespace("future", 
[01:29:11.977]                           quietly = TRUE)
[01:29:11.977]                         if (has_future) {
[01:29:11.977]                           ns <- base::getNamespace("future")
[01:29:11.977]                           version <- ns[[".package"]][["version"]]
[01:29:11.977]                           if (is.null(version)) 
[01:29:11.977]                             version <- utils::packageVersion("future")
[01:29:11.977]                         }
[01:29:11.977]                         else {
[01:29:11.977]                           version <- NULL
[01:29:11.977]                         }
[01:29:11.977]                         if (!has_future || version < "1.8.0") {
[01:29:11.977]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:11.977]                             "", base::R.version$version.string), 
[01:29:11.977]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:11.977]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:11.977]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:11.977]                               "release", "version")], collapse = " "), 
[01:29:11.977]                             hostname = base::Sys.info()[["nodename"]])
[01:29:11.977]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:11.977]                             info)
[01:29:11.977]                           info <- base::paste(info, collapse = "; ")
[01:29:11.977]                           if (!has_future) {
[01:29:11.977]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:11.977]                               info)
[01:29:11.977]                           }
[01:29:11.977]                           else {
[01:29:11.977]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:11.977]                               info, version)
[01:29:11.977]                           }
[01:29:11.977]                           base::stop(msg)
[01:29:11.977]                         }
[01:29:11.977]                       })
[01:29:11.977]                     }
[01:29:11.977]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:11.977]                     base::options(mc.cores = 1L)
[01:29:11.977]                   }
[01:29:11.977]                   options(future.plan = NULL)
[01:29:11.977]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:11.977]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:11.977]                 }
[01:29:11.977]                 ...future.workdir <- getwd()
[01:29:11.977]             }
[01:29:11.977]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:11.977]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:11.977]         }
[01:29:11.977]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:11.977]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:11.977]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:11.977]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:11.977]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:11.977]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:11.977]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:11.977]             base::names(...future.oldOptions))
[01:29:11.977]     }
[01:29:11.977]     if (FALSE) {
[01:29:11.977]     }
[01:29:11.977]     else {
[01:29:11.977]         if (TRUE) {
[01:29:11.977]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:11.977]                 open = "w")
[01:29:11.977]         }
[01:29:11.977]         else {
[01:29:11.977]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:11.977]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:11.977]         }
[01:29:11.977]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:11.977]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:11.977]             base::sink(type = "output", split = FALSE)
[01:29:11.977]             base::close(...future.stdout)
[01:29:11.977]         }, add = TRUE)
[01:29:11.977]     }
[01:29:11.977]     ...future.frame <- base::sys.nframe()
[01:29:11.977]     ...future.conditions <- base::list()
[01:29:11.977]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:11.977]     if (FALSE) {
[01:29:11.977]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:11.977]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:11.977]     }
[01:29:11.977]     ...future.result <- base::tryCatch({
[01:29:11.977]         base::withCallingHandlers({
[01:29:11.977]             ...future.value <- base::withVisible(base::local({
[01:29:11.977]                 ...future.makeSendCondition <- base::local({
[01:29:11.977]                   sendCondition <- NULL
[01:29:11.977]                   function(frame = 1L) {
[01:29:11.977]                     if (is.function(sendCondition)) 
[01:29:11.977]                       return(sendCondition)
[01:29:11.977]                     ns <- getNamespace("parallel")
[01:29:11.977]                     if (exists("sendData", mode = "function", 
[01:29:11.977]                       envir = ns)) {
[01:29:11.977]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:11.977]                         envir = ns)
[01:29:11.977]                       envir <- sys.frame(frame)
[01:29:11.977]                       master <- NULL
[01:29:11.977]                       while (!identical(envir, .GlobalEnv) && 
[01:29:11.977]                         !identical(envir, emptyenv())) {
[01:29:11.977]                         if (exists("master", mode = "list", envir = envir, 
[01:29:11.977]                           inherits = FALSE)) {
[01:29:11.977]                           master <- get("master", mode = "list", 
[01:29:11.977]                             envir = envir, inherits = FALSE)
[01:29:11.977]                           if (inherits(master, c("SOCKnode", 
[01:29:11.977]                             "SOCK0node"))) {
[01:29:11.977]                             sendCondition <<- function(cond) {
[01:29:11.977]                               data <- list(type = "VALUE", value = cond, 
[01:29:11.977]                                 success = TRUE)
[01:29:11.977]                               parallel_sendData(master, data)
[01:29:11.977]                             }
[01:29:11.977]                             return(sendCondition)
[01:29:11.977]                           }
[01:29:11.977]                         }
[01:29:11.977]                         frame <- frame + 1L
[01:29:11.977]                         envir <- sys.frame(frame)
[01:29:11.977]                       }
[01:29:11.977]                     }
[01:29:11.977]                     sendCondition <<- function(cond) NULL
[01:29:11.977]                   }
[01:29:11.977]                 })
[01:29:11.977]                 withCallingHandlers({
[01:29:11.977]                   2
[01:29:11.977]                 }, immediateCondition = function(cond) {
[01:29:11.977]                   sendCondition <- ...future.makeSendCondition()
[01:29:11.977]                   sendCondition(cond)
[01:29:11.977]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:11.977]                   {
[01:29:11.977]                     inherits <- base::inherits
[01:29:11.977]                     invokeRestart <- base::invokeRestart
[01:29:11.977]                     is.null <- base::is.null
[01:29:11.977]                     muffled <- FALSE
[01:29:11.977]                     if (inherits(cond, "message")) {
[01:29:11.977]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:11.977]                       if (muffled) 
[01:29:11.977]                         invokeRestart("muffleMessage")
[01:29:11.977]                     }
[01:29:11.977]                     else if (inherits(cond, "warning")) {
[01:29:11.977]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:11.977]                       if (muffled) 
[01:29:11.977]                         invokeRestart("muffleWarning")
[01:29:11.977]                     }
[01:29:11.977]                     else if (inherits(cond, "condition")) {
[01:29:11.977]                       if (!is.null(pattern)) {
[01:29:11.977]                         computeRestarts <- base::computeRestarts
[01:29:11.977]                         grepl <- base::grepl
[01:29:11.977]                         restarts <- computeRestarts(cond)
[01:29:11.977]                         for (restart in restarts) {
[01:29:11.977]                           name <- restart$name
[01:29:11.977]                           if (is.null(name)) 
[01:29:11.977]                             next
[01:29:11.977]                           if (!grepl(pattern, name)) 
[01:29:11.977]                             next
[01:29:11.977]                           invokeRestart(restart)
[01:29:11.977]                           muffled <- TRUE
[01:29:11.977]                           break
[01:29:11.977]                         }
[01:29:11.977]                       }
[01:29:11.977]                     }
[01:29:11.977]                     invisible(muffled)
[01:29:11.977]                   }
[01:29:11.977]                   muffleCondition(cond)
[01:29:11.977]                 })
[01:29:11.977]             }))
[01:29:11.977]             future::FutureResult(value = ...future.value$value, 
[01:29:11.977]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:11.977]                   ...future.rng), globalenv = if (FALSE) 
[01:29:11.977]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:11.977]                     ...future.globalenv.names))
[01:29:11.977]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:11.977]         }, condition = base::local({
[01:29:11.977]             c <- base::c
[01:29:11.977]             inherits <- base::inherits
[01:29:11.977]             invokeRestart <- base::invokeRestart
[01:29:11.977]             length <- base::length
[01:29:11.977]             list <- base::list
[01:29:11.977]             seq.int <- base::seq.int
[01:29:11.977]             signalCondition <- base::signalCondition
[01:29:11.977]             sys.calls <- base::sys.calls
[01:29:11.977]             `[[` <- base::`[[`
[01:29:11.977]             `+` <- base::`+`
[01:29:11.977]             `<<-` <- base::`<<-`
[01:29:11.977]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:11.977]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:11.977]                   3L)]
[01:29:11.977]             }
[01:29:11.977]             function(cond) {
[01:29:11.977]                 is_error <- inherits(cond, "error")
[01:29:11.977]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:11.977]                   NULL)
[01:29:11.977]                 if (is_error) {
[01:29:11.977]                   sessionInformation <- function() {
[01:29:11.977]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:11.977]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:11.977]                       search = base::search(), system = base::Sys.info())
[01:29:11.977]                   }
[01:29:11.977]                   ...future.conditions[[length(...future.conditions) + 
[01:29:11.977]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:11.977]                     cond$call), session = sessionInformation(), 
[01:29:11.977]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:11.977]                   signalCondition(cond)
[01:29:11.977]                 }
[01:29:11.977]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:11.977]                 "immediateCondition"))) {
[01:29:11.977]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:11.977]                   ...future.conditions[[length(...future.conditions) + 
[01:29:11.977]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:11.977]                   if (TRUE && !signal) {
[01:29:11.977]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:11.977]                     {
[01:29:11.977]                       inherits <- base::inherits
[01:29:11.977]                       invokeRestart <- base::invokeRestart
[01:29:11.977]                       is.null <- base::is.null
[01:29:11.977]                       muffled <- FALSE
[01:29:11.977]                       if (inherits(cond, "message")) {
[01:29:11.977]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:11.977]                         if (muffled) 
[01:29:11.977]                           invokeRestart("muffleMessage")
[01:29:11.977]                       }
[01:29:11.977]                       else if (inherits(cond, "warning")) {
[01:29:11.977]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:11.977]                         if (muffled) 
[01:29:11.977]                           invokeRestart("muffleWarning")
[01:29:11.977]                       }
[01:29:11.977]                       else if (inherits(cond, "condition")) {
[01:29:11.977]                         if (!is.null(pattern)) {
[01:29:11.977]                           computeRestarts <- base::computeRestarts
[01:29:11.977]                           grepl <- base::grepl
[01:29:11.977]                           restarts <- computeRestarts(cond)
[01:29:11.977]                           for (restart in restarts) {
[01:29:11.977]                             name <- restart$name
[01:29:11.977]                             if (is.null(name)) 
[01:29:11.977]                               next
[01:29:11.977]                             if (!grepl(pattern, name)) 
[01:29:11.977]                               next
[01:29:11.977]                             invokeRestart(restart)
[01:29:11.977]                             muffled <- TRUE
[01:29:11.977]                             break
[01:29:11.977]                           }
[01:29:11.977]                         }
[01:29:11.977]                       }
[01:29:11.977]                       invisible(muffled)
[01:29:11.977]                     }
[01:29:11.977]                     muffleCondition(cond, pattern = "^muffle")
[01:29:11.977]                   }
[01:29:11.977]                 }
[01:29:11.977]                 else {
[01:29:11.977]                   if (TRUE) {
[01:29:11.977]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:11.977]                     {
[01:29:11.977]                       inherits <- base::inherits
[01:29:11.977]                       invokeRestart <- base::invokeRestart
[01:29:11.977]                       is.null <- base::is.null
[01:29:11.977]                       muffled <- FALSE
[01:29:11.977]                       if (inherits(cond, "message")) {
[01:29:11.977]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:11.977]                         if (muffled) 
[01:29:11.977]                           invokeRestart("muffleMessage")
[01:29:11.977]                       }
[01:29:11.977]                       else if (inherits(cond, "warning")) {
[01:29:11.977]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:11.977]                         if (muffled) 
[01:29:11.977]                           invokeRestart("muffleWarning")
[01:29:11.977]                       }
[01:29:11.977]                       else if (inherits(cond, "condition")) {
[01:29:11.977]                         if (!is.null(pattern)) {
[01:29:11.977]                           computeRestarts <- base::computeRestarts
[01:29:11.977]                           grepl <- base::grepl
[01:29:11.977]                           restarts <- computeRestarts(cond)
[01:29:11.977]                           for (restart in restarts) {
[01:29:11.977]                             name <- restart$name
[01:29:11.977]                             if (is.null(name)) 
[01:29:11.977]                               next
[01:29:11.977]                             if (!grepl(pattern, name)) 
[01:29:11.977]                               next
[01:29:11.977]                             invokeRestart(restart)
[01:29:11.977]                             muffled <- TRUE
[01:29:11.977]                             break
[01:29:11.977]                           }
[01:29:11.977]                         }
[01:29:11.977]                       }
[01:29:11.977]                       invisible(muffled)
[01:29:11.977]                     }
[01:29:11.977]                     muffleCondition(cond, pattern = "^muffle")
[01:29:11.977]                   }
[01:29:11.977]                 }
[01:29:11.977]             }
[01:29:11.977]         }))
[01:29:11.977]     }, error = function(ex) {
[01:29:11.977]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:11.977]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:11.977]                 ...future.rng), started = ...future.startTime, 
[01:29:11.977]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:11.977]             version = "1.8"), class = "FutureResult")
[01:29:11.977]     }, finally = {
[01:29:11.977]         if (!identical(...future.workdir, getwd())) 
[01:29:11.977]             setwd(...future.workdir)
[01:29:11.977]         {
[01:29:11.977]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:11.977]                 ...future.oldOptions$nwarnings <- NULL
[01:29:11.977]             }
[01:29:11.977]             base::options(...future.oldOptions)
[01:29:11.977]             if (.Platform$OS.type == "windows") {
[01:29:11.977]                 old_names <- names(...future.oldEnvVars)
[01:29:11.977]                 envs <- base::Sys.getenv()
[01:29:11.977]                 names <- names(envs)
[01:29:11.977]                 common <- intersect(names, old_names)
[01:29:11.977]                 added <- setdiff(names, old_names)
[01:29:11.977]                 removed <- setdiff(old_names, names)
[01:29:11.977]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:11.977]                   envs[common]]
[01:29:11.977]                 NAMES <- toupper(changed)
[01:29:11.977]                 args <- list()
[01:29:11.977]                 for (kk in seq_along(NAMES)) {
[01:29:11.977]                   name <- changed[[kk]]
[01:29:11.977]                   NAME <- NAMES[[kk]]
[01:29:11.977]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:11.977]                     next
[01:29:11.977]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:11.977]                 }
[01:29:11.977]                 NAMES <- toupper(added)
[01:29:11.977]                 for (kk in seq_along(NAMES)) {
[01:29:11.977]                   name <- added[[kk]]
[01:29:11.977]                   NAME <- NAMES[[kk]]
[01:29:11.977]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:11.977]                     next
[01:29:11.977]                   args[[name]] <- ""
[01:29:11.977]                 }
[01:29:11.977]                 NAMES <- toupper(removed)
[01:29:11.977]                 for (kk in seq_along(NAMES)) {
[01:29:11.977]                   name <- removed[[kk]]
[01:29:11.977]                   NAME <- NAMES[[kk]]
[01:29:11.977]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:11.977]                     next
[01:29:11.977]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:11.977]                 }
[01:29:11.977]                 if (length(args) > 0) 
[01:29:11.977]                   base::do.call(base::Sys.setenv, args = args)
[01:29:11.977]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:11.977]             }
[01:29:11.977]             else {
[01:29:11.977]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:11.977]             }
[01:29:11.977]             {
[01:29:11.977]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:11.977]                   0L) {
[01:29:11.977]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:11.977]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:11.977]                   base::options(opts)
[01:29:11.977]                 }
[01:29:11.977]                 {
[01:29:11.977]                   {
[01:29:11.977]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:11.977]                     NULL
[01:29:11.977]                   }
[01:29:11.977]                   options(future.plan = NULL)
[01:29:11.977]                   if (is.na(NA_character_)) 
[01:29:11.977]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:11.977]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:11.977]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:11.977]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:11.977]                     envir = parent.frame()) 
[01:29:11.977]                   {
[01:29:11.977]                     if (is.function(workers)) 
[01:29:11.977]                       workers <- workers()
[01:29:11.977]                     workers <- structure(as.integer(workers), 
[01:29:11.977]                       class = class(workers))
[01:29:11.977]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:11.977]                       workers >= 1)
[01:29:11.977]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:11.977]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:11.977]                     }
[01:29:11.977]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:11.977]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:11.977]                       envir = envir)
[01:29:11.977]                     if (!future$lazy) 
[01:29:11.977]                       future <- run(future)
[01:29:11.977]                     invisible(future)
[01:29:11.977]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:11.977]                 }
[01:29:11.977]             }
[01:29:11.977]         }
[01:29:11.977]     })
[01:29:11.977]     if (TRUE) {
[01:29:11.977]         base::sink(type = "output", split = FALSE)
[01:29:11.977]         if (TRUE) {
[01:29:11.977]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:11.977]         }
[01:29:11.977]         else {
[01:29:11.977]             ...future.result["stdout"] <- base::list(NULL)
[01:29:11.977]         }
[01:29:11.977]         base::close(...future.stdout)
[01:29:11.977]         ...future.stdout <- NULL
[01:29:11.977]     }
[01:29:11.977]     ...future.result$conditions <- ...future.conditions
[01:29:11.977]     ...future.result$finished <- base::Sys.time()
[01:29:11.977]     ...future.result
[01:29:11.977] }
[01:29:11.983] MultisessionFuture started
[01:29:11.983] - Launch lazy future ... done
[01:29:11.984] run() for 'MultisessionFuture' ... done
[01:29:12.002] receiveMessageFromWorker() for ClusterFuture ...
[01:29:12.002] - Validating connection of MultisessionFuture
[01:29:12.003] - received message: FutureResult
[01:29:12.003] - Received FutureResult
[01:29:12.003] - Erased future from FutureRegistry
[01:29:12.003] result() for ClusterFuture ...
[01:29:12.003] - result already collected: FutureResult
[01:29:12.004] result() for ClusterFuture ... done
[01:29:12.004] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:12.004] Future #2
[01:29:12.004]  length: 1 (resolved future 2)
[01:29:12.004]  length: 0 (resolved future 3)
[01:29:12.004] resolve() on list ... DONE
[01:29:12.005] getGlobalsAndPackages() ...
[01:29:12.005] Searching for globals...
[01:29:12.005] 
[01:29:12.006] Searching for globals ... DONE
[01:29:12.006] - globals: [0] <none>
[01:29:12.006] getGlobalsAndPackages() ... DONE
[01:29:12.006] run() for 'Future' ...
[01:29:12.006] - state: 'created'
[01:29:12.007] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:12.027] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:12.027] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:12.028]   - Field: 'node'
[01:29:12.028]   - Field: 'label'
[01:29:12.028]   - Field: 'local'
[01:29:12.028]   - Field: 'owner'
[01:29:12.028]   - Field: 'envir'
[01:29:12.028]   - Field: 'workers'
[01:29:12.029]   - Field: 'packages'
[01:29:12.029]   - Field: 'gc'
[01:29:12.029]   - Field: 'conditions'
[01:29:12.029]   - Field: 'persistent'
[01:29:12.029]   - Field: 'expr'
[01:29:12.030]   - Field: 'uuid'
[01:29:12.030]   - Field: 'seed'
[01:29:12.030]   - Field: 'version'
[01:29:12.030]   - Field: 'result'
[01:29:12.030]   - Field: 'asynchronous'
[01:29:12.030]   - Field: 'calls'
[01:29:12.031]   - Field: 'globals'
[01:29:12.031]   - Field: 'stdout'
[01:29:12.031]   - Field: 'earlySignal'
[01:29:12.031]   - Field: 'lazy'
[01:29:12.031]   - Field: 'state'
[01:29:12.032] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:12.032] - Launch lazy future ...
[01:29:12.032] Packages needed by the future expression (n = 0): <none>
[01:29:12.032] Packages needed by future strategies (n = 0): <none>
[01:29:12.033] {
[01:29:12.033]     {
[01:29:12.033]         {
[01:29:12.033]             ...future.startTime <- base::Sys.time()
[01:29:12.033]             {
[01:29:12.033]                 {
[01:29:12.033]                   {
[01:29:12.033]                     {
[01:29:12.033]                       base::local({
[01:29:12.033]                         has_future <- base::requireNamespace("future", 
[01:29:12.033]                           quietly = TRUE)
[01:29:12.033]                         if (has_future) {
[01:29:12.033]                           ns <- base::getNamespace("future")
[01:29:12.033]                           version <- ns[[".package"]][["version"]]
[01:29:12.033]                           if (is.null(version)) 
[01:29:12.033]                             version <- utils::packageVersion("future")
[01:29:12.033]                         }
[01:29:12.033]                         else {
[01:29:12.033]                           version <- NULL
[01:29:12.033]                         }
[01:29:12.033]                         if (!has_future || version < "1.8.0") {
[01:29:12.033]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:12.033]                             "", base::R.version$version.string), 
[01:29:12.033]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:12.033]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:12.033]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:12.033]                               "release", "version")], collapse = " "), 
[01:29:12.033]                             hostname = base::Sys.info()[["nodename"]])
[01:29:12.033]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:12.033]                             info)
[01:29:12.033]                           info <- base::paste(info, collapse = "; ")
[01:29:12.033]                           if (!has_future) {
[01:29:12.033]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:12.033]                               info)
[01:29:12.033]                           }
[01:29:12.033]                           else {
[01:29:12.033]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:12.033]                               info, version)
[01:29:12.033]                           }
[01:29:12.033]                           base::stop(msg)
[01:29:12.033]                         }
[01:29:12.033]                       })
[01:29:12.033]                     }
[01:29:12.033]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:12.033]                     base::options(mc.cores = 1L)
[01:29:12.033]                   }
[01:29:12.033]                   options(future.plan = NULL)
[01:29:12.033]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:12.033]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:12.033]                 }
[01:29:12.033]                 ...future.workdir <- getwd()
[01:29:12.033]             }
[01:29:12.033]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:12.033]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:12.033]         }
[01:29:12.033]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:12.033]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:12.033]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:12.033]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:12.033]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:12.033]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:12.033]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:12.033]             base::names(...future.oldOptions))
[01:29:12.033]     }
[01:29:12.033]     if (FALSE) {
[01:29:12.033]     }
[01:29:12.033]     else {
[01:29:12.033]         if (TRUE) {
[01:29:12.033]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:12.033]                 open = "w")
[01:29:12.033]         }
[01:29:12.033]         else {
[01:29:12.033]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:12.033]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:12.033]         }
[01:29:12.033]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:12.033]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:12.033]             base::sink(type = "output", split = FALSE)
[01:29:12.033]             base::close(...future.stdout)
[01:29:12.033]         }, add = TRUE)
[01:29:12.033]     }
[01:29:12.033]     ...future.frame <- base::sys.nframe()
[01:29:12.033]     ...future.conditions <- base::list()
[01:29:12.033]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:12.033]     if (FALSE) {
[01:29:12.033]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:12.033]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:12.033]     }
[01:29:12.033]     ...future.result <- base::tryCatch({
[01:29:12.033]         base::withCallingHandlers({
[01:29:12.033]             ...future.value <- base::withVisible(base::local({
[01:29:12.033]                 ...future.makeSendCondition <- base::local({
[01:29:12.033]                   sendCondition <- NULL
[01:29:12.033]                   function(frame = 1L) {
[01:29:12.033]                     if (is.function(sendCondition)) 
[01:29:12.033]                       return(sendCondition)
[01:29:12.033]                     ns <- getNamespace("parallel")
[01:29:12.033]                     if (exists("sendData", mode = "function", 
[01:29:12.033]                       envir = ns)) {
[01:29:12.033]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:12.033]                         envir = ns)
[01:29:12.033]                       envir <- sys.frame(frame)
[01:29:12.033]                       master <- NULL
[01:29:12.033]                       while (!identical(envir, .GlobalEnv) && 
[01:29:12.033]                         !identical(envir, emptyenv())) {
[01:29:12.033]                         if (exists("master", mode = "list", envir = envir, 
[01:29:12.033]                           inherits = FALSE)) {
[01:29:12.033]                           master <- get("master", mode = "list", 
[01:29:12.033]                             envir = envir, inherits = FALSE)
[01:29:12.033]                           if (inherits(master, c("SOCKnode", 
[01:29:12.033]                             "SOCK0node"))) {
[01:29:12.033]                             sendCondition <<- function(cond) {
[01:29:12.033]                               data <- list(type = "VALUE", value = cond, 
[01:29:12.033]                                 success = TRUE)
[01:29:12.033]                               parallel_sendData(master, data)
[01:29:12.033]                             }
[01:29:12.033]                             return(sendCondition)
[01:29:12.033]                           }
[01:29:12.033]                         }
[01:29:12.033]                         frame <- frame + 1L
[01:29:12.033]                         envir <- sys.frame(frame)
[01:29:12.033]                       }
[01:29:12.033]                     }
[01:29:12.033]                     sendCondition <<- function(cond) NULL
[01:29:12.033]                   }
[01:29:12.033]                 })
[01:29:12.033]                 withCallingHandlers({
[01:29:12.033]                   1
[01:29:12.033]                 }, immediateCondition = function(cond) {
[01:29:12.033]                   sendCondition <- ...future.makeSendCondition()
[01:29:12.033]                   sendCondition(cond)
[01:29:12.033]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:12.033]                   {
[01:29:12.033]                     inherits <- base::inherits
[01:29:12.033]                     invokeRestart <- base::invokeRestart
[01:29:12.033]                     is.null <- base::is.null
[01:29:12.033]                     muffled <- FALSE
[01:29:12.033]                     if (inherits(cond, "message")) {
[01:29:12.033]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:12.033]                       if (muffled) 
[01:29:12.033]                         invokeRestart("muffleMessage")
[01:29:12.033]                     }
[01:29:12.033]                     else if (inherits(cond, "warning")) {
[01:29:12.033]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:12.033]                       if (muffled) 
[01:29:12.033]                         invokeRestart("muffleWarning")
[01:29:12.033]                     }
[01:29:12.033]                     else if (inherits(cond, "condition")) {
[01:29:12.033]                       if (!is.null(pattern)) {
[01:29:12.033]                         computeRestarts <- base::computeRestarts
[01:29:12.033]                         grepl <- base::grepl
[01:29:12.033]                         restarts <- computeRestarts(cond)
[01:29:12.033]                         for (restart in restarts) {
[01:29:12.033]                           name <- restart$name
[01:29:12.033]                           if (is.null(name)) 
[01:29:12.033]                             next
[01:29:12.033]                           if (!grepl(pattern, name)) 
[01:29:12.033]                             next
[01:29:12.033]                           invokeRestart(restart)
[01:29:12.033]                           muffled <- TRUE
[01:29:12.033]                           break
[01:29:12.033]                         }
[01:29:12.033]                       }
[01:29:12.033]                     }
[01:29:12.033]                     invisible(muffled)
[01:29:12.033]                   }
[01:29:12.033]                   muffleCondition(cond)
[01:29:12.033]                 })
[01:29:12.033]             }))
[01:29:12.033]             future::FutureResult(value = ...future.value$value, 
[01:29:12.033]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:12.033]                   ...future.rng), globalenv = if (FALSE) 
[01:29:12.033]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:12.033]                     ...future.globalenv.names))
[01:29:12.033]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:12.033]         }, condition = base::local({
[01:29:12.033]             c <- base::c
[01:29:12.033]             inherits <- base::inherits
[01:29:12.033]             invokeRestart <- base::invokeRestart
[01:29:12.033]             length <- base::length
[01:29:12.033]             list <- base::list
[01:29:12.033]             seq.int <- base::seq.int
[01:29:12.033]             signalCondition <- base::signalCondition
[01:29:12.033]             sys.calls <- base::sys.calls
[01:29:12.033]             `[[` <- base::`[[`
[01:29:12.033]             `+` <- base::`+`
[01:29:12.033]             `<<-` <- base::`<<-`
[01:29:12.033]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:12.033]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:12.033]                   3L)]
[01:29:12.033]             }
[01:29:12.033]             function(cond) {
[01:29:12.033]                 is_error <- inherits(cond, "error")
[01:29:12.033]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:12.033]                   NULL)
[01:29:12.033]                 if (is_error) {
[01:29:12.033]                   sessionInformation <- function() {
[01:29:12.033]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:12.033]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:12.033]                       search = base::search(), system = base::Sys.info())
[01:29:12.033]                   }
[01:29:12.033]                   ...future.conditions[[length(...future.conditions) + 
[01:29:12.033]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:12.033]                     cond$call), session = sessionInformation(), 
[01:29:12.033]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:12.033]                   signalCondition(cond)
[01:29:12.033]                 }
[01:29:12.033]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:12.033]                 "immediateCondition"))) {
[01:29:12.033]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:12.033]                   ...future.conditions[[length(...future.conditions) + 
[01:29:12.033]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:12.033]                   if (TRUE && !signal) {
[01:29:12.033]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:12.033]                     {
[01:29:12.033]                       inherits <- base::inherits
[01:29:12.033]                       invokeRestart <- base::invokeRestart
[01:29:12.033]                       is.null <- base::is.null
[01:29:12.033]                       muffled <- FALSE
[01:29:12.033]                       if (inherits(cond, "message")) {
[01:29:12.033]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:12.033]                         if (muffled) 
[01:29:12.033]                           invokeRestart("muffleMessage")
[01:29:12.033]                       }
[01:29:12.033]                       else if (inherits(cond, "warning")) {
[01:29:12.033]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:12.033]                         if (muffled) 
[01:29:12.033]                           invokeRestart("muffleWarning")
[01:29:12.033]                       }
[01:29:12.033]                       else if (inherits(cond, "condition")) {
[01:29:12.033]                         if (!is.null(pattern)) {
[01:29:12.033]                           computeRestarts <- base::computeRestarts
[01:29:12.033]                           grepl <- base::grepl
[01:29:12.033]                           restarts <- computeRestarts(cond)
[01:29:12.033]                           for (restart in restarts) {
[01:29:12.033]                             name <- restart$name
[01:29:12.033]                             if (is.null(name)) 
[01:29:12.033]                               next
[01:29:12.033]                             if (!grepl(pattern, name)) 
[01:29:12.033]                               next
[01:29:12.033]                             invokeRestart(restart)
[01:29:12.033]                             muffled <- TRUE
[01:29:12.033]                             break
[01:29:12.033]                           }
[01:29:12.033]                         }
[01:29:12.033]                       }
[01:29:12.033]                       invisible(muffled)
[01:29:12.033]                     }
[01:29:12.033]                     muffleCondition(cond, pattern = "^muffle")
[01:29:12.033]                   }
[01:29:12.033]                 }
[01:29:12.033]                 else {
[01:29:12.033]                   if (TRUE) {
[01:29:12.033]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:12.033]                     {
[01:29:12.033]                       inherits <- base::inherits
[01:29:12.033]                       invokeRestart <- base::invokeRestart
[01:29:12.033]                       is.null <- base::is.null
[01:29:12.033]                       muffled <- FALSE
[01:29:12.033]                       if (inherits(cond, "message")) {
[01:29:12.033]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:12.033]                         if (muffled) 
[01:29:12.033]                           invokeRestart("muffleMessage")
[01:29:12.033]                       }
[01:29:12.033]                       else if (inherits(cond, "warning")) {
[01:29:12.033]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:12.033]                         if (muffled) 
[01:29:12.033]                           invokeRestart("muffleWarning")
[01:29:12.033]                       }
[01:29:12.033]                       else if (inherits(cond, "condition")) {
[01:29:12.033]                         if (!is.null(pattern)) {
[01:29:12.033]                           computeRestarts <- base::computeRestarts
[01:29:12.033]                           grepl <- base::grepl
[01:29:12.033]                           restarts <- computeRestarts(cond)
[01:29:12.033]                           for (restart in restarts) {
[01:29:12.033]                             name <- restart$name
[01:29:12.033]                             if (is.null(name)) 
[01:29:12.033]                               next
[01:29:12.033]                             if (!grepl(pattern, name)) 
[01:29:12.033]                               next
[01:29:12.033]                             invokeRestart(restart)
[01:29:12.033]                             muffled <- TRUE
[01:29:12.033]                             break
[01:29:12.033]                           }
[01:29:12.033]                         }
[01:29:12.033]                       }
[01:29:12.033]                       invisible(muffled)
[01:29:12.033]                     }
[01:29:12.033]                     muffleCondition(cond, pattern = "^muffle")
[01:29:12.033]                   }
[01:29:12.033]                 }
[01:29:12.033]             }
[01:29:12.033]         }))
[01:29:12.033]     }, error = function(ex) {
[01:29:12.033]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:12.033]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:12.033]                 ...future.rng), started = ...future.startTime, 
[01:29:12.033]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:12.033]             version = "1.8"), class = "FutureResult")
[01:29:12.033]     }, finally = {
[01:29:12.033]         if (!identical(...future.workdir, getwd())) 
[01:29:12.033]             setwd(...future.workdir)
[01:29:12.033]         {
[01:29:12.033]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:12.033]                 ...future.oldOptions$nwarnings <- NULL
[01:29:12.033]             }
[01:29:12.033]             base::options(...future.oldOptions)
[01:29:12.033]             if (.Platform$OS.type == "windows") {
[01:29:12.033]                 old_names <- names(...future.oldEnvVars)
[01:29:12.033]                 envs <- base::Sys.getenv()
[01:29:12.033]                 names <- names(envs)
[01:29:12.033]                 common <- intersect(names, old_names)
[01:29:12.033]                 added <- setdiff(names, old_names)
[01:29:12.033]                 removed <- setdiff(old_names, names)
[01:29:12.033]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:12.033]                   envs[common]]
[01:29:12.033]                 NAMES <- toupper(changed)
[01:29:12.033]                 args <- list()
[01:29:12.033]                 for (kk in seq_along(NAMES)) {
[01:29:12.033]                   name <- changed[[kk]]
[01:29:12.033]                   NAME <- NAMES[[kk]]
[01:29:12.033]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:12.033]                     next
[01:29:12.033]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:12.033]                 }
[01:29:12.033]                 NAMES <- toupper(added)
[01:29:12.033]                 for (kk in seq_along(NAMES)) {
[01:29:12.033]                   name <- added[[kk]]
[01:29:12.033]                   NAME <- NAMES[[kk]]
[01:29:12.033]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:12.033]                     next
[01:29:12.033]                   args[[name]] <- ""
[01:29:12.033]                 }
[01:29:12.033]                 NAMES <- toupper(removed)
[01:29:12.033]                 for (kk in seq_along(NAMES)) {
[01:29:12.033]                   name <- removed[[kk]]
[01:29:12.033]                   NAME <- NAMES[[kk]]
[01:29:12.033]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:12.033]                     next
[01:29:12.033]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:12.033]                 }
[01:29:12.033]                 if (length(args) > 0) 
[01:29:12.033]                   base::do.call(base::Sys.setenv, args = args)
[01:29:12.033]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:12.033]             }
[01:29:12.033]             else {
[01:29:12.033]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:12.033]             }
[01:29:12.033]             {
[01:29:12.033]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:12.033]                   0L) {
[01:29:12.033]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:12.033]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:12.033]                   base::options(opts)
[01:29:12.033]                 }
[01:29:12.033]                 {
[01:29:12.033]                   {
[01:29:12.033]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:12.033]                     NULL
[01:29:12.033]                   }
[01:29:12.033]                   options(future.plan = NULL)
[01:29:12.033]                   if (is.na(NA_character_)) 
[01:29:12.033]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:12.033]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:12.033]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:12.033]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:12.033]                     envir = parent.frame()) 
[01:29:12.033]                   {
[01:29:12.033]                     if (is.function(workers)) 
[01:29:12.033]                       workers <- workers()
[01:29:12.033]                     workers <- structure(as.integer(workers), 
[01:29:12.033]                       class = class(workers))
[01:29:12.033]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:12.033]                       workers >= 1)
[01:29:12.033]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:12.033]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:12.033]                     }
[01:29:12.033]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:12.033]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:12.033]                       envir = envir)
[01:29:12.033]                     if (!future$lazy) 
[01:29:12.033]                       future <- run(future)
[01:29:12.033]                     invisible(future)
[01:29:12.033]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:12.033]                 }
[01:29:12.033]             }
[01:29:12.033]         }
[01:29:12.033]     })
[01:29:12.033]     if (TRUE) {
[01:29:12.033]         base::sink(type = "output", split = FALSE)
[01:29:12.033]         if (TRUE) {
[01:29:12.033]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:12.033]         }
[01:29:12.033]         else {
[01:29:12.033]             ...future.result["stdout"] <- base::list(NULL)
[01:29:12.033]         }
[01:29:12.033]         base::close(...future.stdout)
[01:29:12.033]         ...future.stdout <- NULL
[01:29:12.033]     }
[01:29:12.033]     ...future.result$conditions <- ...future.conditions
[01:29:12.033]     ...future.result$finished <- base::Sys.time()
[01:29:12.033]     ...future.result
[01:29:12.033] }
[01:29:12.040] MultisessionFuture started
[01:29:12.040] - Launch lazy future ... done
[01:29:12.040] run() for 'MultisessionFuture' ... done
[01:29:12.040] getGlobalsAndPackages() ...
[01:29:12.041] Searching for globals...
[01:29:12.042] - globals found: [2] '{', 'Sys.sleep'
[01:29:12.042] Searching for globals ... DONE
[01:29:12.042] Resolving globals: FALSE
[01:29:12.043] 
[01:29:12.043] 
[01:29:12.043] getGlobalsAndPackages() ... DONE
[01:29:12.044] run() for 'Future' ...
[01:29:12.044] - state: 'created'
[01:29:12.044] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:12.060] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:12.061] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:12.061]   - Field: 'node'
[01:29:12.061]   - Field: 'label'
[01:29:12.061]   - Field: 'local'
[01:29:12.061]   - Field: 'owner'
[01:29:12.062]   - Field: 'envir'
[01:29:12.062]   - Field: 'workers'
[01:29:12.062]   - Field: 'packages'
[01:29:12.062]   - Field: 'gc'
[01:29:12.063]   - Field: 'conditions'
[01:29:12.063]   - Field: 'persistent'
[01:29:12.063]   - Field: 'expr'
[01:29:12.063]   - Field: 'uuid'
[01:29:12.063]   - Field: 'seed'
[01:29:12.064]   - Field: 'version'
[01:29:12.064]   - Field: 'result'
[01:29:12.064]   - Field: 'asynchronous'
[01:29:12.064]   - Field: 'calls'
[01:29:12.064]   - Field: 'globals'
[01:29:12.064]   - Field: 'stdout'
[01:29:12.065]   - Field: 'earlySignal'
[01:29:12.065]   - Field: 'lazy'
[01:29:12.065]   - Field: 'state'
[01:29:12.065] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:12.065] - Launch lazy future ...
[01:29:12.066] Packages needed by the future expression (n = 0): <none>
[01:29:12.066] Packages needed by future strategies (n = 0): <none>
[01:29:12.067] {
[01:29:12.067]     {
[01:29:12.067]         {
[01:29:12.067]             ...future.startTime <- base::Sys.time()
[01:29:12.067]             {
[01:29:12.067]                 {
[01:29:12.067]                   {
[01:29:12.067]                     {
[01:29:12.067]                       base::local({
[01:29:12.067]                         has_future <- base::requireNamespace("future", 
[01:29:12.067]                           quietly = TRUE)
[01:29:12.067]                         if (has_future) {
[01:29:12.067]                           ns <- base::getNamespace("future")
[01:29:12.067]                           version <- ns[[".package"]][["version"]]
[01:29:12.067]                           if (is.null(version)) 
[01:29:12.067]                             version <- utils::packageVersion("future")
[01:29:12.067]                         }
[01:29:12.067]                         else {
[01:29:12.067]                           version <- NULL
[01:29:12.067]                         }
[01:29:12.067]                         if (!has_future || version < "1.8.0") {
[01:29:12.067]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:12.067]                             "", base::R.version$version.string), 
[01:29:12.067]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:12.067]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:12.067]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:12.067]                               "release", "version")], collapse = " "), 
[01:29:12.067]                             hostname = base::Sys.info()[["nodename"]])
[01:29:12.067]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:12.067]                             info)
[01:29:12.067]                           info <- base::paste(info, collapse = "; ")
[01:29:12.067]                           if (!has_future) {
[01:29:12.067]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:12.067]                               info)
[01:29:12.067]                           }
[01:29:12.067]                           else {
[01:29:12.067]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:12.067]                               info, version)
[01:29:12.067]                           }
[01:29:12.067]                           base::stop(msg)
[01:29:12.067]                         }
[01:29:12.067]                       })
[01:29:12.067]                     }
[01:29:12.067]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:12.067]                     base::options(mc.cores = 1L)
[01:29:12.067]                   }
[01:29:12.067]                   options(future.plan = NULL)
[01:29:12.067]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:12.067]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:12.067]                 }
[01:29:12.067]                 ...future.workdir <- getwd()
[01:29:12.067]             }
[01:29:12.067]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:12.067]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:12.067]         }
[01:29:12.067]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:12.067]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:12.067]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:12.067]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:12.067]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:12.067]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:12.067]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:12.067]             base::names(...future.oldOptions))
[01:29:12.067]     }
[01:29:12.067]     if (FALSE) {
[01:29:12.067]     }
[01:29:12.067]     else {
[01:29:12.067]         if (TRUE) {
[01:29:12.067]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:12.067]                 open = "w")
[01:29:12.067]         }
[01:29:12.067]         else {
[01:29:12.067]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:12.067]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:12.067]         }
[01:29:12.067]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:12.067]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:12.067]             base::sink(type = "output", split = FALSE)
[01:29:12.067]             base::close(...future.stdout)
[01:29:12.067]         }, add = TRUE)
[01:29:12.067]     }
[01:29:12.067]     ...future.frame <- base::sys.nframe()
[01:29:12.067]     ...future.conditions <- base::list()
[01:29:12.067]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:12.067]     if (FALSE) {
[01:29:12.067]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:12.067]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:12.067]     }
[01:29:12.067]     ...future.result <- base::tryCatch({
[01:29:12.067]         base::withCallingHandlers({
[01:29:12.067]             ...future.value <- base::withVisible(base::local({
[01:29:12.067]                 ...future.makeSendCondition <- base::local({
[01:29:12.067]                   sendCondition <- NULL
[01:29:12.067]                   function(frame = 1L) {
[01:29:12.067]                     if (is.function(sendCondition)) 
[01:29:12.067]                       return(sendCondition)
[01:29:12.067]                     ns <- getNamespace("parallel")
[01:29:12.067]                     if (exists("sendData", mode = "function", 
[01:29:12.067]                       envir = ns)) {
[01:29:12.067]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:12.067]                         envir = ns)
[01:29:12.067]                       envir <- sys.frame(frame)
[01:29:12.067]                       master <- NULL
[01:29:12.067]                       while (!identical(envir, .GlobalEnv) && 
[01:29:12.067]                         !identical(envir, emptyenv())) {
[01:29:12.067]                         if (exists("master", mode = "list", envir = envir, 
[01:29:12.067]                           inherits = FALSE)) {
[01:29:12.067]                           master <- get("master", mode = "list", 
[01:29:12.067]                             envir = envir, inherits = FALSE)
[01:29:12.067]                           if (inherits(master, c("SOCKnode", 
[01:29:12.067]                             "SOCK0node"))) {
[01:29:12.067]                             sendCondition <<- function(cond) {
[01:29:12.067]                               data <- list(type = "VALUE", value = cond, 
[01:29:12.067]                                 success = TRUE)
[01:29:12.067]                               parallel_sendData(master, data)
[01:29:12.067]                             }
[01:29:12.067]                             return(sendCondition)
[01:29:12.067]                           }
[01:29:12.067]                         }
[01:29:12.067]                         frame <- frame + 1L
[01:29:12.067]                         envir <- sys.frame(frame)
[01:29:12.067]                       }
[01:29:12.067]                     }
[01:29:12.067]                     sendCondition <<- function(cond) NULL
[01:29:12.067]                   }
[01:29:12.067]                 })
[01:29:12.067]                 withCallingHandlers({
[01:29:12.067]                   {
[01:29:12.067]                     Sys.sleep(0.5)
[01:29:12.067]                     2
[01:29:12.067]                   }
[01:29:12.067]                 }, immediateCondition = function(cond) {
[01:29:12.067]                   sendCondition <- ...future.makeSendCondition()
[01:29:12.067]                   sendCondition(cond)
[01:29:12.067]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:12.067]                   {
[01:29:12.067]                     inherits <- base::inherits
[01:29:12.067]                     invokeRestart <- base::invokeRestart
[01:29:12.067]                     is.null <- base::is.null
[01:29:12.067]                     muffled <- FALSE
[01:29:12.067]                     if (inherits(cond, "message")) {
[01:29:12.067]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:12.067]                       if (muffled) 
[01:29:12.067]                         invokeRestart("muffleMessage")
[01:29:12.067]                     }
[01:29:12.067]                     else if (inherits(cond, "warning")) {
[01:29:12.067]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:12.067]                       if (muffled) 
[01:29:12.067]                         invokeRestart("muffleWarning")
[01:29:12.067]                     }
[01:29:12.067]                     else if (inherits(cond, "condition")) {
[01:29:12.067]                       if (!is.null(pattern)) {
[01:29:12.067]                         computeRestarts <- base::computeRestarts
[01:29:12.067]                         grepl <- base::grepl
[01:29:12.067]                         restarts <- computeRestarts(cond)
[01:29:12.067]                         for (restart in restarts) {
[01:29:12.067]                           name <- restart$name
[01:29:12.067]                           if (is.null(name)) 
[01:29:12.067]                             next
[01:29:12.067]                           if (!grepl(pattern, name)) 
[01:29:12.067]                             next
[01:29:12.067]                           invokeRestart(restart)
[01:29:12.067]                           muffled <- TRUE
[01:29:12.067]                           break
[01:29:12.067]                         }
[01:29:12.067]                       }
[01:29:12.067]                     }
[01:29:12.067]                     invisible(muffled)
[01:29:12.067]                   }
[01:29:12.067]                   muffleCondition(cond)
[01:29:12.067]                 })
[01:29:12.067]             }))
[01:29:12.067]             future::FutureResult(value = ...future.value$value, 
[01:29:12.067]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:12.067]                   ...future.rng), globalenv = if (FALSE) 
[01:29:12.067]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:12.067]                     ...future.globalenv.names))
[01:29:12.067]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:12.067]         }, condition = base::local({
[01:29:12.067]             c <- base::c
[01:29:12.067]             inherits <- base::inherits
[01:29:12.067]             invokeRestart <- base::invokeRestart
[01:29:12.067]             length <- base::length
[01:29:12.067]             list <- base::list
[01:29:12.067]             seq.int <- base::seq.int
[01:29:12.067]             signalCondition <- base::signalCondition
[01:29:12.067]             sys.calls <- base::sys.calls
[01:29:12.067]             `[[` <- base::`[[`
[01:29:12.067]             `+` <- base::`+`
[01:29:12.067]             `<<-` <- base::`<<-`
[01:29:12.067]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:12.067]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:12.067]                   3L)]
[01:29:12.067]             }
[01:29:12.067]             function(cond) {
[01:29:12.067]                 is_error <- inherits(cond, "error")
[01:29:12.067]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:12.067]                   NULL)
[01:29:12.067]                 if (is_error) {
[01:29:12.067]                   sessionInformation <- function() {
[01:29:12.067]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:12.067]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:12.067]                       search = base::search(), system = base::Sys.info())
[01:29:12.067]                   }
[01:29:12.067]                   ...future.conditions[[length(...future.conditions) + 
[01:29:12.067]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:12.067]                     cond$call), session = sessionInformation(), 
[01:29:12.067]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:12.067]                   signalCondition(cond)
[01:29:12.067]                 }
[01:29:12.067]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:12.067]                 "immediateCondition"))) {
[01:29:12.067]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:12.067]                   ...future.conditions[[length(...future.conditions) + 
[01:29:12.067]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:12.067]                   if (TRUE && !signal) {
[01:29:12.067]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:12.067]                     {
[01:29:12.067]                       inherits <- base::inherits
[01:29:12.067]                       invokeRestart <- base::invokeRestart
[01:29:12.067]                       is.null <- base::is.null
[01:29:12.067]                       muffled <- FALSE
[01:29:12.067]                       if (inherits(cond, "message")) {
[01:29:12.067]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:12.067]                         if (muffled) 
[01:29:12.067]                           invokeRestart("muffleMessage")
[01:29:12.067]                       }
[01:29:12.067]                       else if (inherits(cond, "warning")) {
[01:29:12.067]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:12.067]                         if (muffled) 
[01:29:12.067]                           invokeRestart("muffleWarning")
[01:29:12.067]                       }
[01:29:12.067]                       else if (inherits(cond, "condition")) {
[01:29:12.067]                         if (!is.null(pattern)) {
[01:29:12.067]                           computeRestarts <- base::computeRestarts
[01:29:12.067]                           grepl <- base::grepl
[01:29:12.067]                           restarts <- computeRestarts(cond)
[01:29:12.067]                           for (restart in restarts) {
[01:29:12.067]                             name <- restart$name
[01:29:12.067]                             if (is.null(name)) 
[01:29:12.067]                               next
[01:29:12.067]                             if (!grepl(pattern, name)) 
[01:29:12.067]                               next
[01:29:12.067]                             invokeRestart(restart)
[01:29:12.067]                             muffled <- TRUE
[01:29:12.067]                             break
[01:29:12.067]                           }
[01:29:12.067]                         }
[01:29:12.067]                       }
[01:29:12.067]                       invisible(muffled)
[01:29:12.067]                     }
[01:29:12.067]                     muffleCondition(cond, pattern = "^muffle")
[01:29:12.067]                   }
[01:29:12.067]                 }
[01:29:12.067]                 else {
[01:29:12.067]                   if (TRUE) {
[01:29:12.067]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:12.067]                     {
[01:29:12.067]                       inherits <- base::inherits
[01:29:12.067]                       invokeRestart <- base::invokeRestart
[01:29:12.067]                       is.null <- base::is.null
[01:29:12.067]                       muffled <- FALSE
[01:29:12.067]                       if (inherits(cond, "message")) {
[01:29:12.067]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:12.067]                         if (muffled) 
[01:29:12.067]                           invokeRestart("muffleMessage")
[01:29:12.067]                       }
[01:29:12.067]                       else if (inherits(cond, "warning")) {
[01:29:12.067]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:12.067]                         if (muffled) 
[01:29:12.067]                           invokeRestart("muffleWarning")
[01:29:12.067]                       }
[01:29:12.067]                       else if (inherits(cond, "condition")) {
[01:29:12.067]                         if (!is.null(pattern)) {
[01:29:12.067]                           computeRestarts <- base::computeRestarts
[01:29:12.067]                           grepl <- base::grepl
[01:29:12.067]                           restarts <- computeRestarts(cond)
[01:29:12.067]                           for (restart in restarts) {
[01:29:12.067]                             name <- restart$name
[01:29:12.067]                             if (is.null(name)) 
[01:29:12.067]                               next
[01:29:12.067]                             if (!grepl(pattern, name)) 
[01:29:12.067]                               next
[01:29:12.067]                             invokeRestart(restart)
[01:29:12.067]                             muffled <- TRUE
[01:29:12.067]                             break
[01:29:12.067]                           }
[01:29:12.067]                         }
[01:29:12.067]                       }
[01:29:12.067]                       invisible(muffled)
[01:29:12.067]                     }
[01:29:12.067]                     muffleCondition(cond, pattern = "^muffle")
[01:29:12.067]                   }
[01:29:12.067]                 }
[01:29:12.067]             }
[01:29:12.067]         }))
[01:29:12.067]     }, error = function(ex) {
[01:29:12.067]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:12.067]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:12.067]                 ...future.rng), started = ...future.startTime, 
[01:29:12.067]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:12.067]             version = "1.8"), class = "FutureResult")
[01:29:12.067]     }, finally = {
[01:29:12.067]         if (!identical(...future.workdir, getwd())) 
[01:29:12.067]             setwd(...future.workdir)
[01:29:12.067]         {
[01:29:12.067]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:12.067]                 ...future.oldOptions$nwarnings <- NULL
[01:29:12.067]             }
[01:29:12.067]             base::options(...future.oldOptions)
[01:29:12.067]             if (.Platform$OS.type == "windows") {
[01:29:12.067]                 old_names <- names(...future.oldEnvVars)
[01:29:12.067]                 envs <- base::Sys.getenv()
[01:29:12.067]                 names <- names(envs)
[01:29:12.067]                 common <- intersect(names, old_names)
[01:29:12.067]                 added <- setdiff(names, old_names)
[01:29:12.067]                 removed <- setdiff(old_names, names)
[01:29:12.067]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:12.067]                   envs[common]]
[01:29:12.067]                 NAMES <- toupper(changed)
[01:29:12.067]                 args <- list()
[01:29:12.067]                 for (kk in seq_along(NAMES)) {
[01:29:12.067]                   name <- changed[[kk]]
[01:29:12.067]                   NAME <- NAMES[[kk]]
[01:29:12.067]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:12.067]                     next
[01:29:12.067]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:12.067]                 }
[01:29:12.067]                 NAMES <- toupper(added)
[01:29:12.067]                 for (kk in seq_along(NAMES)) {
[01:29:12.067]                   name <- added[[kk]]
[01:29:12.067]                   NAME <- NAMES[[kk]]
[01:29:12.067]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:12.067]                     next
[01:29:12.067]                   args[[name]] <- ""
[01:29:12.067]                 }
[01:29:12.067]                 NAMES <- toupper(removed)
[01:29:12.067]                 for (kk in seq_along(NAMES)) {
[01:29:12.067]                   name <- removed[[kk]]
[01:29:12.067]                   NAME <- NAMES[[kk]]
[01:29:12.067]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:12.067]                     next
[01:29:12.067]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:12.067]                 }
[01:29:12.067]                 if (length(args) > 0) 
[01:29:12.067]                   base::do.call(base::Sys.setenv, args = args)
[01:29:12.067]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:12.067]             }
[01:29:12.067]             else {
[01:29:12.067]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:12.067]             }
[01:29:12.067]             {
[01:29:12.067]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:12.067]                   0L) {
[01:29:12.067]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:12.067]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:12.067]                   base::options(opts)
[01:29:12.067]                 }
[01:29:12.067]                 {
[01:29:12.067]                   {
[01:29:12.067]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:12.067]                     NULL
[01:29:12.067]                   }
[01:29:12.067]                   options(future.plan = NULL)
[01:29:12.067]                   if (is.na(NA_character_)) 
[01:29:12.067]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:12.067]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:12.067]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:12.067]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:12.067]                     envir = parent.frame()) 
[01:29:12.067]                   {
[01:29:12.067]                     if (is.function(workers)) 
[01:29:12.067]                       workers <- workers()
[01:29:12.067]                     workers <- structure(as.integer(workers), 
[01:29:12.067]                       class = class(workers))
[01:29:12.067]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:12.067]                       workers >= 1)
[01:29:12.067]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:12.067]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:12.067]                     }
[01:29:12.067]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:12.067]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:12.067]                       envir = envir)
[01:29:12.067]                     if (!future$lazy) 
[01:29:12.067]                       future <- run(future)
[01:29:12.067]                     invisible(future)
[01:29:12.067]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:12.067]                 }
[01:29:12.067]             }
[01:29:12.067]         }
[01:29:12.067]     })
[01:29:12.067]     if (TRUE) {
[01:29:12.067]         base::sink(type = "output", split = FALSE)
[01:29:12.067]         if (TRUE) {
[01:29:12.067]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:12.067]         }
[01:29:12.067]         else {
[01:29:12.067]             ...future.result["stdout"] <- base::list(NULL)
[01:29:12.067]         }
[01:29:12.067]         base::close(...future.stdout)
[01:29:12.067]         ...future.stdout <- NULL
[01:29:12.067]     }
[01:29:12.067]     ...future.result$conditions <- ...future.conditions
[01:29:12.067]     ...future.result$finished <- base::Sys.time()
[01:29:12.067]     ...future.result
[01:29:12.067] }
[01:29:12.073] MultisessionFuture started
[01:29:12.074] - Launch lazy future ... done
[01:29:12.074] run() for 'MultisessionFuture' ... done
[01:29:12.074] resolve() on list ...
[01:29:12.074]  recursive: 0
[01:29:12.075]  length: 1
[01:29:12.075] 
[01:29:12.075] receiveMessageFromWorker() for ClusterFuture ...
[01:29:12.076] - Validating connection of MultisessionFuture
[01:29:12.076] - received message: FutureResult
[01:29:12.076] - Received FutureResult
[01:29:12.076] - Erased future from FutureRegistry
[01:29:12.076] result() for ClusterFuture ...
[01:29:12.077] - result already collected: FutureResult
[01:29:12.077] result() for ClusterFuture ... done
[01:29:12.077] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:12.077] Future #1
[01:29:12.077]  length: 0 (resolved future 1)
[01:29:12.077] resolve() on list ... DONE
[01:29:12.078] resolve() on list ...
[01:29:12.078]  recursive: 0
[01:29:12.078]  length: 1
[01:29:12.078] 
[01:29:12.596] receiveMessageFromWorker() for ClusterFuture ...
[01:29:12.596] - Validating connection of MultisessionFuture
[01:29:12.596] - received message: FutureResult
[01:29:12.597] - Received FutureResult
[01:29:12.597] - Erased future from FutureRegistry
[01:29:12.597] result() for ClusterFuture ...
[01:29:12.597] - result already collected: FutureResult
[01:29:12.597] result() for ClusterFuture ... done
[01:29:12.598] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:12.598] Future #1
[01:29:12.598]  length: 0 (resolved future 1)
[01:29:12.598] resolve() on list ... DONE
[01:29:12.598] resolve() on list ...
[01:29:12.599]  recursive: 0
[01:29:12.599]  length: 1
[01:29:12.599] 
[01:29:12.599]  length: 0 (resolved future 1)
[01:29:12.599] resolve() on list ... DONE
[01:29:12.600] resolve() on list ...
[01:29:12.600]  recursive: 0
[01:29:12.600]  length: 4
[01:29:12.600] 
[01:29:12.600] Future #1
[01:29:12.600]  length: 3 (resolved future 1)
[01:29:12.601] Future #2
[01:29:12.601]  length: 2 (resolved future 2)
[01:29:12.601]  length: 1 (resolved future 3)
[01:29:12.601]  length: 0 (resolved future 4)
[01:29:12.601] resolve() on list ... DONE
[01:29:12.602] resolve() on list ...
[01:29:12.602]  recursive: 0
[01:29:12.602]  length: 4
[01:29:12.602] 
[01:29:12.602] Future #1
[01:29:12.602]  length: 3 (resolved future 1)
[01:29:12.603] Future #2
[01:29:12.603]  length: 2 (resolved future 2)
[01:29:12.603]  length: 1 (resolved future 3)
[01:29:12.603]  length: 0 (resolved future 4)
[01:29:12.603] resolve() on list ... DONE
[01:29:12.604] resolve() on list ...
[01:29:12.604]  recursive: 0
[01:29:12.604]  length: 1
[01:29:12.604] 
[01:29:12.604]  length: 0 (resolved future 1)
[01:29:12.604] resolve() on list ... DONE
[01:29:12.605] getGlobalsAndPackages() ...
[01:29:12.605] Searching for globals...
[01:29:12.606] - globals found: [3] '{', 'Sys.sleep', 'kk'
[01:29:12.606] Searching for globals ... DONE
[01:29:12.606] Resolving globals: FALSE
[01:29:12.607] The total size of the 1 globals is 56 bytes (56 bytes)
[01:29:12.607] The total size of the 1 globals exported for future expression ('{; Sys.sleep(0.1); kk; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'kk' (56 bytes of class 'numeric')
[01:29:12.608] - globals: [1] 'kk'
[01:29:12.608] 
[01:29:12.608] getGlobalsAndPackages() ... DONE
[01:29:12.609] run() for 'Future' ...
[01:29:12.609] - state: 'created'
[01:29:12.609] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:12.624] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:12.624] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:12.624]   - Field: 'node'
[01:29:12.624]   - Field: 'label'
[01:29:12.625]   - Field: 'local'
[01:29:12.625]   - Field: 'owner'
[01:29:12.625]   - Field: 'envir'
[01:29:12.625]   - Field: 'workers'
[01:29:12.625]   - Field: 'packages'
[01:29:12.625]   - Field: 'gc'
[01:29:12.626]   - Field: 'conditions'
[01:29:12.626]   - Field: 'persistent'
[01:29:12.626]   - Field: 'expr'
[01:29:12.626]   - Field: 'uuid'
[01:29:12.626]   - Field: 'seed'
[01:29:12.627]   - Field: 'version'
[01:29:12.627]   - Field: 'result'
[01:29:12.627]   - Field: 'asynchronous'
[01:29:12.627]   - Field: 'calls'
[01:29:12.627]   - Field: 'globals'
[01:29:12.627]   - Field: 'stdout'
[01:29:12.628]   - Field: 'earlySignal'
[01:29:12.628]   - Field: 'lazy'
[01:29:12.628]   - Field: 'state'
[01:29:12.628] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:12.628] - Launch lazy future ...
[01:29:12.629] Packages needed by the future expression (n = 0): <none>
[01:29:12.629] Packages needed by future strategies (n = 0): <none>
[01:29:12.630] {
[01:29:12.630]     {
[01:29:12.630]         {
[01:29:12.630]             ...future.startTime <- base::Sys.time()
[01:29:12.630]             {
[01:29:12.630]                 {
[01:29:12.630]                   {
[01:29:12.630]                     {
[01:29:12.630]                       base::local({
[01:29:12.630]                         has_future <- base::requireNamespace("future", 
[01:29:12.630]                           quietly = TRUE)
[01:29:12.630]                         if (has_future) {
[01:29:12.630]                           ns <- base::getNamespace("future")
[01:29:12.630]                           version <- ns[[".package"]][["version"]]
[01:29:12.630]                           if (is.null(version)) 
[01:29:12.630]                             version <- utils::packageVersion("future")
[01:29:12.630]                         }
[01:29:12.630]                         else {
[01:29:12.630]                           version <- NULL
[01:29:12.630]                         }
[01:29:12.630]                         if (!has_future || version < "1.8.0") {
[01:29:12.630]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:12.630]                             "", base::R.version$version.string), 
[01:29:12.630]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:12.630]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:12.630]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:12.630]                               "release", "version")], collapse = " "), 
[01:29:12.630]                             hostname = base::Sys.info()[["nodename"]])
[01:29:12.630]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:12.630]                             info)
[01:29:12.630]                           info <- base::paste(info, collapse = "; ")
[01:29:12.630]                           if (!has_future) {
[01:29:12.630]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:12.630]                               info)
[01:29:12.630]                           }
[01:29:12.630]                           else {
[01:29:12.630]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:12.630]                               info, version)
[01:29:12.630]                           }
[01:29:12.630]                           base::stop(msg)
[01:29:12.630]                         }
[01:29:12.630]                       })
[01:29:12.630]                     }
[01:29:12.630]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:12.630]                     base::options(mc.cores = 1L)
[01:29:12.630]                   }
[01:29:12.630]                   options(future.plan = NULL)
[01:29:12.630]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:12.630]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:12.630]                 }
[01:29:12.630]                 ...future.workdir <- getwd()
[01:29:12.630]             }
[01:29:12.630]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:12.630]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:12.630]         }
[01:29:12.630]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:12.630]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:12.630]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:12.630]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:12.630]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:12.630]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:12.630]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:12.630]             base::names(...future.oldOptions))
[01:29:12.630]     }
[01:29:12.630]     if (FALSE) {
[01:29:12.630]     }
[01:29:12.630]     else {
[01:29:12.630]         if (TRUE) {
[01:29:12.630]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:12.630]                 open = "w")
[01:29:12.630]         }
[01:29:12.630]         else {
[01:29:12.630]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:12.630]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:12.630]         }
[01:29:12.630]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:12.630]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:12.630]             base::sink(type = "output", split = FALSE)
[01:29:12.630]             base::close(...future.stdout)
[01:29:12.630]         }, add = TRUE)
[01:29:12.630]     }
[01:29:12.630]     ...future.frame <- base::sys.nframe()
[01:29:12.630]     ...future.conditions <- base::list()
[01:29:12.630]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:12.630]     if (FALSE) {
[01:29:12.630]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:12.630]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:12.630]     }
[01:29:12.630]     ...future.result <- base::tryCatch({
[01:29:12.630]         base::withCallingHandlers({
[01:29:12.630]             ...future.value <- base::withVisible(base::local({
[01:29:12.630]                 ...future.makeSendCondition <- base::local({
[01:29:12.630]                   sendCondition <- NULL
[01:29:12.630]                   function(frame = 1L) {
[01:29:12.630]                     if (is.function(sendCondition)) 
[01:29:12.630]                       return(sendCondition)
[01:29:12.630]                     ns <- getNamespace("parallel")
[01:29:12.630]                     if (exists("sendData", mode = "function", 
[01:29:12.630]                       envir = ns)) {
[01:29:12.630]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:12.630]                         envir = ns)
[01:29:12.630]                       envir <- sys.frame(frame)
[01:29:12.630]                       master <- NULL
[01:29:12.630]                       while (!identical(envir, .GlobalEnv) && 
[01:29:12.630]                         !identical(envir, emptyenv())) {
[01:29:12.630]                         if (exists("master", mode = "list", envir = envir, 
[01:29:12.630]                           inherits = FALSE)) {
[01:29:12.630]                           master <- get("master", mode = "list", 
[01:29:12.630]                             envir = envir, inherits = FALSE)
[01:29:12.630]                           if (inherits(master, c("SOCKnode", 
[01:29:12.630]                             "SOCK0node"))) {
[01:29:12.630]                             sendCondition <<- function(cond) {
[01:29:12.630]                               data <- list(type = "VALUE", value = cond, 
[01:29:12.630]                                 success = TRUE)
[01:29:12.630]                               parallel_sendData(master, data)
[01:29:12.630]                             }
[01:29:12.630]                             return(sendCondition)
[01:29:12.630]                           }
[01:29:12.630]                         }
[01:29:12.630]                         frame <- frame + 1L
[01:29:12.630]                         envir <- sys.frame(frame)
[01:29:12.630]                       }
[01:29:12.630]                     }
[01:29:12.630]                     sendCondition <<- function(cond) NULL
[01:29:12.630]                   }
[01:29:12.630]                 })
[01:29:12.630]                 withCallingHandlers({
[01:29:12.630]                   {
[01:29:12.630]                     Sys.sleep(0.1)
[01:29:12.630]                     kk
[01:29:12.630]                   }
[01:29:12.630]                 }, immediateCondition = function(cond) {
[01:29:12.630]                   sendCondition <- ...future.makeSendCondition()
[01:29:12.630]                   sendCondition(cond)
[01:29:12.630]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:12.630]                   {
[01:29:12.630]                     inherits <- base::inherits
[01:29:12.630]                     invokeRestart <- base::invokeRestart
[01:29:12.630]                     is.null <- base::is.null
[01:29:12.630]                     muffled <- FALSE
[01:29:12.630]                     if (inherits(cond, "message")) {
[01:29:12.630]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:12.630]                       if (muffled) 
[01:29:12.630]                         invokeRestart("muffleMessage")
[01:29:12.630]                     }
[01:29:12.630]                     else if (inherits(cond, "warning")) {
[01:29:12.630]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:12.630]                       if (muffled) 
[01:29:12.630]                         invokeRestart("muffleWarning")
[01:29:12.630]                     }
[01:29:12.630]                     else if (inherits(cond, "condition")) {
[01:29:12.630]                       if (!is.null(pattern)) {
[01:29:12.630]                         computeRestarts <- base::computeRestarts
[01:29:12.630]                         grepl <- base::grepl
[01:29:12.630]                         restarts <- computeRestarts(cond)
[01:29:12.630]                         for (restart in restarts) {
[01:29:12.630]                           name <- restart$name
[01:29:12.630]                           if (is.null(name)) 
[01:29:12.630]                             next
[01:29:12.630]                           if (!grepl(pattern, name)) 
[01:29:12.630]                             next
[01:29:12.630]                           invokeRestart(restart)
[01:29:12.630]                           muffled <- TRUE
[01:29:12.630]                           break
[01:29:12.630]                         }
[01:29:12.630]                       }
[01:29:12.630]                     }
[01:29:12.630]                     invisible(muffled)
[01:29:12.630]                   }
[01:29:12.630]                   muffleCondition(cond)
[01:29:12.630]                 })
[01:29:12.630]             }))
[01:29:12.630]             future::FutureResult(value = ...future.value$value, 
[01:29:12.630]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:12.630]                   ...future.rng), globalenv = if (FALSE) 
[01:29:12.630]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:12.630]                     ...future.globalenv.names))
[01:29:12.630]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:12.630]         }, condition = base::local({
[01:29:12.630]             c <- base::c
[01:29:12.630]             inherits <- base::inherits
[01:29:12.630]             invokeRestart <- base::invokeRestart
[01:29:12.630]             length <- base::length
[01:29:12.630]             list <- base::list
[01:29:12.630]             seq.int <- base::seq.int
[01:29:12.630]             signalCondition <- base::signalCondition
[01:29:12.630]             sys.calls <- base::sys.calls
[01:29:12.630]             `[[` <- base::`[[`
[01:29:12.630]             `+` <- base::`+`
[01:29:12.630]             `<<-` <- base::`<<-`
[01:29:12.630]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:12.630]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:12.630]                   3L)]
[01:29:12.630]             }
[01:29:12.630]             function(cond) {
[01:29:12.630]                 is_error <- inherits(cond, "error")
[01:29:12.630]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:12.630]                   NULL)
[01:29:12.630]                 if (is_error) {
[01:29:12.630]                   sessionInformation <- function() {
[01:29:12.630]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:12.630]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:12.630]                       search = base::search(), system = base::Sys.info())
[01:29:12.630]                   }
[01:29:12.630]                   ...future.conditions[[length(...future.conditions) + 
[01:29:12.630]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:12.630]                     cond$call), session = sessionInformation(), 
[01:29:12.630]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:12.630]                   signalCondition(cond)
[01:29:12.630]                 }
[01:29:12.630]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:12.630]                 "immediateCondition"))) {
[01:29:12.630]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:12.630]                   ...future.conditions[[length(...future.conditions) + 
[01:29:12.630]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:12.630]                   if (TRUE && !signal) {
[01:29:12.630]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:12.630]                     {
[01:29:12.630]                       inherits <- base::inherits
[01:29:12.630]                       invokeRestart <- base::invokeRestart
[01:29:12.630]                       is.null <- base::is.null
[01:29:12.630]                       muffled <- FALSE
[01:29:12.630]                       if (inherits(cond, "message")) {
[01:29:12.630]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:12.630]                         if (muffled) 
[01:29:12.630]                           invokeRestart("muffleMessage")
[01:29:12.630]                       }
[01:29:12.630]                       else if (inherits(cond, "warning")) {
[01:29:12.630]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:12.630]                         if (muffled) 
[01:29:12.630]                           invokeRestart("muffleWarning")
[01:29:12.630]                       }
[01:29:12.630]                       else if (inherits(cond, "condition")) {
[01:29:12.630]                         if (!is.null(pattern)) {
[01:29:12.630]                           computeRestarts <- base::computeRestarts
[01:29:12.630]                           grepl <- base::grepl
[01:29:12.630]                           restarts <- computeRestarts(cond)
[01:29:12.630]                           for (restart in restarts) {
[01:29:12.630]                             name <- restart$name
[01:29:12.630]                             if (is.null(name)) 
[01:29:12.630]                               next
[01:29:12.630]                             if (!grepl(pattern, name)) 
[01:29:12.630]                               next
[01:29:12.630]                             invokeRestart(restart)
[01:29:12.630]                             muffled <- TRUE
[01:29:12.630]                             break
[01:29:12.630]                           }
[01:29:12.630]                         }
[01:29:12.630]                       }
[01:29:12.630]                       invisible(muffled)
[01:29:12.630]                     }
[01:29:12.630]                     muffleCondition(cond, pattern = "^muffle")
[01:29:12.630]                   }
[01:29:12.630]                 }
[01:29:12.630]                 else {
[01:29:12.630]                   if (TRUE) {
[01:29:12.630]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:12.630]                     {
[01:29:12.630]                       inherits <- base::inherits
[01:29:12.630]                       invokeRestart <- base::invokeRestart
[01:29:12.630]                       is.null <- base::is.null
[01:29:12.630]                       muffled <- FALSE
[01:29:12.630]                       if (inherits(cond, "message")) {
[01:29:12.630]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:12.630]                         if (muffled) 
[01:29:12.630]                           invokeRestart("muffleMessage")
[01:29:12.630]                       }
[01:29:12.630]                       else if (inherits(cond, "warning")) {
[01:29:12.630]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:12.630]                         if (muffled) 
[01:29:12.630]                           invokeRestart("muffleWarning")
[01:29:12.630]                       }
[01:29:12.630]                       else if (inherits(cond, "condition")) {
[01:29:12.630]                         if (!is.null(pattern)) {
[01:29:12.630]                           computeRestarts <- base::computeRestarts
[01:29:12.630]                           grepl <- base::grepl
[01:29:12.630]                           restarts <- computeRestarts(cond)
[01:29:12.630]                           for (restart in restarts) {
[01:29:12.630]                             name <- restart$name
[01:29:12.630]                             if (is.null(name)) 
[01:29:12.630]                               next
[01:29:12.630]                             if (!grepl(pattern, name)) 
[01:29:12.630]                               next
[01:29:12.630]                             invokeRestart(restart)
[01:29:12.630]                             muffled <- TRUE
[01:29:12.630]                             break
[01:29:12.630]                           }
[01:29:12.630]                         }
[01:29:12.630]                       }
[01:29:12.630]                       invisible(muffled)
[01:29:12.630]                     }
[01:29:12.630]                     muffleCondition(cond, pattern = "^muffle")
[01:29:12.630]                   }
[01:29:12.630]                 }
[01:29:12.630]             }
[01:29:12.630]         }))
[01:29:12.630]     }, error = function(ex) {
[01:29:12.630]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:12.630]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:12.630]                 ...future.rng), started = ...future.startTime, 
[01:29:12.630]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:12.630]             version = "1.8"), class = "FutureResult")
[01:29:12.630]     }, finally = {
[01:29:12.630]         if (!identical(...future.workdir, getwd())) 
[01:29:12.630]             setwd(...future.workdir)
[01:29:12.630]         {
[01:29:12.630]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:12.630]                 ...future.oldOptions$nwarnings <- NULL
[01:29:12.630]             }
[01:29:12.630]             base::options(...future.oldOptions)
[01:29:12.630]             if (.Platform$OS.type == "windows") {
[01:29:12.630]                 old_names <- names(...future.oldEnvVars)
[01:29:12.630]                 envs <- base::Sys.getenv()
[01:29:12.630]                 names <- names(envs)
[01:29:12.630]                 common <- intersect(names, old_names)
[01:29:12.630]                 added <- setdiff(names, old_names)
[01:29:12.630]                 removed <- setdiff(old_names, names)
[01:29:12.630]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:12.630]                   envs[common]]
[01:29:12.630]                 NAMES <- toupper(changed)
[01:29:12.630]                 args <- list()
[01:29:12.630]                 for (kk in seq_along(NAMES)) {
[01:29:12.630]                   name <- changed[[kk]]
[01:29:12.630]                   NAME <- NAMES[[kk]]
[01:29:12.630]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:12.630]                     next
[01:29:12.630]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:12.630]                 }
[01:29:12.630]                 NAMES <- toupper(added)
[01:29:12.630]                 for (kk in seq_along(NAMES)) {
[01:29:12.630]                   name <- added[[kk]]
[01:29:12.630]                   NAME <- NAMES[[kk]]
[01:29:12.630]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:12.630]                     next
[01:29:12.630]                   args[[name]] <- ""
[01:29:12.630]                 }
[01:29:12.630]                 NAMES <- toupper(removed)
[01:29:12.630]                 for (kk in seq_along(NAMES)) {
[01:29:12.630]                   name <- removed[[kk]]
[01:29:12.630]                   NAME <- NAMES[[kk]]
[01:29:12.630]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:12.630]                     next
[01:29:12.630]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:12.630]                 }
[01:29:12.630]                 if (length(args) > 0) 
[01:29:12.630]                   base::do.call(base::Sys.setenv, args = args)
[01:29:12.630]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:12.630]             }
[01:29:12.630]             else {
[01:29:12.630]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:12.630]             }
[01:29:12.630]             {
[01:29:12.630]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:12.630]                   0L) {
[01:29:12.630]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:12.630]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:12.630]                   base::options(opts)
[01:29:12.630]                 }
[01:29:12.630]                 {
[01:29:12.630]                   {
[01:29:12.630]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:12.630]                     NULL
[01:29:12.630]                   }
[01:29:12.630]                   options(future.plan = NULL)
[01:29:12.630]                   if (is.na(NA_character_)) 
[01:29:12.630]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:12.630]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:12.630]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:12.630]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:12.630]                     envir = parent.frame()) 
[01:29:12.630]                   {
[01:29:12.630]                     if (is.function(workers)) 
[01:29:12.630]                       workers <- workers()
[01:29:12.630]                     workers <- structure(as.integer(workers), 
[01:29:12.630]                       class = class(workers))
[01:29:12.630]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:12.630]                       workers >= 1)
[01:29:12.630]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:12.630]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:12.630]                     }
[01:29:12.630]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:12.630]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:12.630]                       envir = envir)
[01:29:12.630]                     if (!future$lazy) 
[01:29:12.630]                       future <- run(future)
[01:29:12.630]                     invisible(future)
[01:29:12.630]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:12.630]                 }
[01:29:12.630]             }
[01:29:12.630]         }
[01:29:12.630]     })
[01:29:12.630]     if (TRUE) {
[01:29:12.630]         base::sink(type = "output", split = FALSE)
[01:29:12.630]         if (TRUE) {
[01:29:12.630]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:12.630]         }
[01:29:12.630]         else {
[01:29:12.630]             ...future.result["stdout"] <- base::list(NULL)
[01:29:12.630]         }
[01:29:12.630]         base::close(...future.stdout)
[01:29:12.630]         ...future.stdout <- NULL
[01:29:12.630]     }
[01:29:12.630]     ...future.result$conditions <- ...future.conditions
[01:29:12.630]     ...future.result$finished <- base::Sys.time()
[01:29:12.630]     ...future.result
[01:29:12.630] }
[01:29:12.635] Exporting 1 global objects (56 bytes) to cluster node #1 ...
[01:29:12.635] Exporting 'kk' (56 bytes) to cluster node #1 ...
[01:29:12.636] Exporting 'kk' (56 bytes) to cluster node #1 ... DONE
[01:29:12.636] Exporting 1 global objects (56 bytes) to cluster node #1 ... DONE
[01:29:12.637] MultisessionFuture started
[01:29:12.637] - Launch lazy future ... done
[01:29:12.637] run() for 'MultisessionFuture' ... done
[01:29:12.637] getGlobalsAndPackages() ...
[01:29:12.637] Searching for globals...
[01:29:12.638] - globals found: [3] '{', 'Sys.sleep', 'kk'
[01:29:12.639] Searching for globals ... DONE
[01:29:12.639] Resolving globals: FALSE
[01:29:12.639] The total size of the 1 globals is 56 bytes (56 bytes)
[01:29:12.640] The total size of the 1 globals exported for future expression ('{; Sys.sleep(0.1); kk; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'kk' (56 bytes of class 'numeric')
[01:29:12.640] - globals: [1] 'kk'
[01:29:12.640] 
[01:29:12.640] getGlobalsAndPackages() ... DONE
[01:29:12.641] run() for 'Future' ...
[01:29:12.641] - state: 'created'
[01:29:12.641] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:12.655] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:12.656] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:12.656]   - Field: 'node'
[01:29:12.656]   - Field: 'label'
[01:29:12.656]   - Field: 'local'
[01:29:12.657]   - Field: 'owner'
[01:29:12.657]   - Field: 'envir'
[01:29:12.657]   - Field: 'workers'
[01:29:12.657]   - Field: 'packages'
[01:29:12.657]   - Field: 'gc'
[01:29:12.657]   - Field: 'conditions'
[01:29:12.658]   - Field: 'persistent'
[01:29:12.658]   - Field: 'expr'
[01:29:12.658]   - Field: 'uuid'
[01:29:12.658]   - Field: 'seed'
[01:29:12.658]   - Field: 'version'
[01:29:12.659]   - Field: 'result'
[01:29:12.659]   - Field: 'asynchronous'
[01:29:12.659]   - Field: 'calls'
[01:29:12.659]   - Field: 'globals'
[01:29:12.659]   - Field: 'stdout'
[01:29:12.659]   - Field: 'earlySignal'
[01:29:12.660]   - Field: 'lazy'
[01:29:12.660]   - Field: 'state'
[01:29:12.660] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:12.660] - Launch lazy future ...
[01:29:12.660] Packages needed by the future expression (n = 0): <none>
[01:29:12.661] Packages needed by future strategies (n = 0): <none>
[01:29:12.661] {
[01:29:12.661]     {
[01:29:12.661]         {
[01:29:12.661]             ...future.startTime <- base::Sys.time()
[01:29:12.661]             {
[01:29:12.661]                 {
[01:29:12.661]                   {
[01:29:12.661]                     {
[01:29:12.661]                       base::local({
[01:29:12.661]                         has_future <- base::requireNamespace("future", 
[01:29:12.661]                           quietly = TRUE)
[01:29:12.661]                         if (has_future) {
[01:29:12.661]                           ns <- base::getNamespace("future")
[01:29:12.661]                           version <- ns[[".package"]][["version"]]
[01:29:12.661]                           if (is.null(version)) 
[01:29:12.661]                             version <- utils::packageVersion("future")
[01:29:12.661]                         }
[01:29:12.661]                         else {
[01:29:12.661]                           version <- NULL
[01:29:12.661]                         }
[01:29:12.661]                         if (!has_future || version < "1.8.0") {
[01:29:12.661]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:12.661]                             "", base::R.version$version.string), 
[01:29:12.661]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:12.661]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:12.661]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:12.661]                               "release", "version")], collapse = " "), 
[01:29:12.661]                             hostname = base::Sys.info()[["nodename"]])
[01:29:12.661]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:12.661]                             info)
[01:29:12.661]                           info <- base::paste(info, collapse = "; ")
[01:29:12.661]                           if (!has_future) {
[01:29:12.661]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:12.661]                               info)
[01:29:12.661]                           }
[01:29:12.661]                           else {
[01:29:12.661]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:12.661]                               info, version)
[01:29:12.661]                           }
[01:29:12.661]                           base::stop(msg)
[01:29:12.661]                         }
[01:29:12.661]                       })
[01:29:12.661]                     }
[01:29:12.661]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:12.661]                     base::options(mc.cores = 1L)
[01:29:12.661]                   }
[01:29:12.661]                   options(future.plan = NULL)
[01:29:12.661]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:12.661]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:12.661]                 }
[01:29:12.661]                 ...future.workdir <- getwd()
[01:29:12.661]             }
[01:29:12.661]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:12.661]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:12.661]         }
[01:29:12.661]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:12.661]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:12.661]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:12.661]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:12.661]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:12.661]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:12.661]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:12.661]             base::names(...future.oldOptions))
[01:29:12.661]     }
[01:29:12.661]     if (FALSE) {
[01:29:12.661]     }
[01:29:12.661]     else {
[01:29:12.661]         if (TRUE) {
[01:29:12.661]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:12.661]                 open = "w")
[01:29:12.661]         }
[01:29:12.661]         else {
[01:29:12.661]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:12.661]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:12.661]         }
[01:29:12.661]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:12.661]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:12.661]             base::sink(type = "output", split = FALSE)
[01:29:12.661]             base::close(...future.stdout)
[01:29:12.661]         }, add = TRUE)
[01:29:12.661]     }
[01:29:12.661]     ...future.frame <- base::sys.nframe()
[01:29:12.661]     ...future.conditions <- base::list()
[01:29:12.661]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:12.661]     if (FALSE) {
[01:29:12.661]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:12.661]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:12.661]     }
[01:29:12.661]     ...future.result <- base::tryCatch({
[01:29:12.661]         base::withCallingHandlers({
[01:29:12.661]             ...future.value <- base::withVisible(base::local({
[01:29:12.661]                 ...future.makeSendCondition <- base::local({
[01:29:12.661]                   sendCondition <- NULL
[01:29:12.661]                   function(frame = 1L) {
[01:29:12.661]                     if (is.function(sendCondition)) 
[01:29:12.661]                       return(sendCondition)
[01:29:12.661]                     ns <- getNamespace("parallel")
[01:29:12.661]                     if (exists("sendData", mode = "function", 
[01:29:12.661]                       envir = ns)) {
[01:29:12.661]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:12.661]                         envir = ns)
[01:29:12.661]                       envir <- sys.frame(frame)
[01:29:12.661]                       master <- NULL
[01:29:12.661]                       while (!identical(envir, .GlobalEnv) && 
[01:29:12.661]                         !identical(envir, emptyenv())) {
[01:29:12.661]                         if (exists("master", mode = "list", envir = envir, 
[01:29:12.661]                           inherits = FALSE)) {
[01:29:12.661]                           master <- get("master", mode = "list", 
[01:29:12.661]                             envir = envir, inherits = FALSE)
[01:29:12.661]                           if (inherits(master, c("SOCKnode", 
[01:29:12.661]                             "SOCK0node"))) {
[01:29:12.661]                             sendCondition <<- function(cond) {
[01:29:12.661]                               data <- list(type = "VALUE", value = cond, 
[01:29:12.661]                                 success = TRUE)
[01:29:12.661]                               parallel_sendData(master, data)
[01:29:12.661]                             }
[01:29:12.661]                             return(sendCondition)
[01:29:12.661]                           }
[01:29:12.661]                         }
[01:29:12.661]                         frame <- frame + 1L
[01:29:12.661]                         envir <- sys.frame(frame)
[01:29:12.661]                       }
[01:29:12.661]                     }
[01:29:12.661]                     sendCondition <<- function(cond) NULL
[01:29:12.661]                   }
[01:29:12.661]                 })
[01:29:12.661]                 withCallingHandlers({
[01:29:12.661]                   {
[01:29:12.661]                     Sys.sleep(0.1)
[01:29:12.661]                     kk
[01:29:12.661]                   }
[01:29:12.661]                 }, immediateCondition = function(cond) {
[01:29:12.661]                   sendCondition <- ...future.makeSendCondition()
[01:29:12.661]                   sendCondition(cond)
[01:29:12.661]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:12.661]                   {
[01:29:12.661]                     inherits <- base::inherits
[01:29:12.661]                     invokeRestart <- base::invokeRestart
[01:29:12.661]                     is.null <- base::is.null
[01:29:12.661]                     muffled <- FALSE
[01:29:12.661]                     if (inherits(cond, "message")) {
[01:29:12.661]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:12.661]                       if (muffled) 
[01:29:12.661]                         invokeRestart("muffleMessage")
[01:29:12.661]                     }
[01:29:12.661]                     else if (inherits(cond, "warning")) {
[01:29:12.661]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:12.661]                       if (muffled) 
[01:29:12.661]                         invokeRestart("muffleWarning")
[01:29:12.661]                     }
[01:29:12.661]                     else if (inherits(cond, "condition")) {
[01:29:12.661]                       if (!is.null(pattern)) {
[01:29:12.661]                         computeRestarts <- base::computeRestarts
[01:29:12.661]                         grepl <- base::grepl
[01:29:12.661]                         restarts <- computeRestarts(cond)
[01:29:12.661]                         for (restart in restarts) {
[01:29:12.661]                           name <- restart$name
[01:29:12.661]                           if (is.null(name)) 
[01:29:12.661]                             next
[01:29:12.661]                           if (!grepl(pattern, name)) 
[01:29:12.661]                             next
[01:29:12.661]                           invokeRestart(restart)
[01:29:12.661]                           muffled <- TRUE
[01:29:12.661]                           break
[01:29:12.661]                         }
[01:29:12.661]                       }
[01:29:12.661]                     }
[01:29:12.661]                     invisible(muffled)
[01:29:12.661]                   }
[01:29:12.661]                   muffleCondition(cond)
[01:29:12.661]                 })
[01:29:12.661]             }))
[01:29:12.661]             future::FutureResult(value = ...future.value$value, 
[01:29:12.661]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:12.661]                   ...future.rng), globalenv = if (FALSE) 
[01:29:12.661]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:12.661]                     ...future.globalenv.names))
[01:29:12.661]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:12.661]         }, condition = base::local({
[01:29:12.661]             c <- base::c
[01:29:12.661]             inherits <- base::inherits
[01:29:12.661]             invokeRestart <- base::invokeRestart
[01:29:12.661]             length <- base::length
[01:29:12.661]             list <- base::list
[01:29:12.661]             seq.int <- base::seq.int
[01:29:12.661]             signalCondition <- base::signalCondition
[01:29:12.661]             sys.calls <- base::sys.calls
[01:29:12.661]             `[[` <- base::`[[`
[01:29:12.661]             `+` <- base::`+`
[01:29:12.661]             `<<-` <- base::`<<-`
[01:29:12.661]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:12.661]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:12.661]                   3L)]
[01:29:12.661]             }
[01:29:12.661]             function(cond) {
[01:29:12.661]                 is_error <- inherits(cond, "error")
[01:29:12.661]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:12.661]                   NULL)
[01:29:12.661]                 if (is_error) {
[01:29:12.661]                   sessionInformation <- function() {
[01:29:12.661]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:12.661]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:12.661]                       search = base::search(), system = base::Sys.info())
[01:29:12.661]                   }
[01:29:12.661]                   ...future.conditions[[length(...future.conditions) + 
[01:29:12.661]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:12.661]                     cond$call), session = sessionInformation(), 
[01:29:12.661]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:12.661]                   signalCondition(cond)
[01:29:12.661]                 }
[01:29:12.661]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:12.661]                 "immediateCondition"))) {
[01:29:12.661]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:12.661]                   ...future.conditions[[length(...future.conditions) + 
[01:29:12.661]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:12.661]                   if (TRUE && !signal) {
[01:29:12.661]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:12.661]                     {
[01:29:12.661]                       inherits <- base::inherits
[01:29:12.661]                       invokeRestart <- base::invokeRestart
[01:29:12.661]                       is.null <- base::is.null
[01:29:12.661]                       muffled <- FALSE
[01:29:12.661]                       if (inherits(cond, "message")) {
[01:29:12.661]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:12.661]                         if (muffled) 
[01:29:12.661]                           invokeRestart("muffleMessage")
[01:29:12.661]                       }
[01:29:12.661]                       else if (inherits(cond, "warning")) {
[01:29:12.661]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:12.661]                         if (muffled) 
[01:29:12.661]                           invokeRestart("muffleWarning")
[01:29:12.661]                       }
[01:29:12.661]                       else if (inherits(cond, "condition")) {
[01:29:12.661]                         if (!is.null(pattern)) {
[01:29:12.661]                           computeRestarts <- base::computeRestarts
[01:29:12.661]                           grepl <- base::grepl
[01:29:12.661]                           restarts <- computeRestarts(cond)
[01:29:12.661]                           for (restart in restarts) {
[01:29:12.661]                             name <- restart$name
[01:29:12.661]                             if (is.null(name)) 
[01:29:12.661]                               next
[01:29:12.661]                             if (!grepl(pattern, name)) 
[01:29:12.661]                               next
[01:29:12.661]                             invokeRestart(restart)
[01:29:12.661]                             muffled <- TRUE
[01:29:12.661]                             break
[01:29:12.661]                           }
[01:29:12.661]                         }
[01:29:12.661]                       }
[01:29:12.661]                       invisible(muffled)
[01:29:12.661]                     }
[01:29:12.661]                     muffleCondition(cond, pattern = "^muffle")
[01:29:12.661]                   }
[01:29:12.661]                 }
[01:29:12.661]                 else {
[01:29:12.661]                   if (TRUE) {
[01:29:12.661]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:12.661]                     {
[01:29:12.661]                       inherits <- base::inherits
[01:29:12.661]                       invokeRestart <- base::invokeRestart
[01:29:12.661]                       is.null <- base::is.null
[01:29:12.661]                       muffled <- FALSE
[01:29:12.661]                       if (inherits(cond, "message")) {
[01:29:12.661]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:12.661]                         if (muffled) 
[01:29:12.661]                           invokeRestart("muffleMessage")
[01:29:12.661]                       }
[01:29:12.661]                       else if (inherits(cond, "warning")) {
[01:29:12.661]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:12.661]                         if (muffled) 
[01:29:12.661]                           invokeRestart("muffleWarning")
[01:29:12.661]                       }
[01:29:12.661]                       else if (inherits(cond, "condition")) {
[01:29:12.661]                         if (!is.null(pattern)) {
[01:29:12.661]                           computeRestarts <- base::computeRestarts
[01:29:12.661]                           grepl <- base::grepl
[01:29:12.661]                           restarts <- computeRestarts(cond)
[01:29:12.661]                           for (restart in restarts) {
[01:29:12.661]                             name <- restart$name
[01:29:12.661]                             if (is.null(name)) 
[01:29:12.661]                               next
[01:29:12.661]                             if (!grepl(pattern, name)) 
[01:29:12.661]                               next
[01:29:12.661]                             invokeRestart(restart)
[01:29:12.661]                             muffled <- TRUE
[01:29:12.661]                             break
[01:29:12.661]                           }
[01:29:12.661]                         }
[01:29:12.661]                       }
[01:29:12.661]                       invisible(muffled)
[01:29:12.661]                     }
[01:29:12.661]                     muffleCondition(cond, pattern = "^muffle")
[01:29:12.661]                   }
[01:29:12.661]                 }
[01:29:12.661]             }
[01:29:12.661]         }))
[01:29:12.661]     }, error = function(ex) {
[01:29:12.661]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:12.661]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:12.661]                 ...future.rng), started = ...future.startTime, 
[01:29:12.661]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:12.661]             version = "1.8"), class = "FutureResult")
[01:29:12.661]     }, finally = {
[01:29:12.661]         if (!identical(...future.workdir, getwd())) 
[01:29:12.661]             setwd(...future.workdir)
[01:29:12.661]         {
[01:29:12.661]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:12.661]                 ...future.oldOptions$nwarnings <- NULL
[01:29:12.661]             }
[01:29:12.661]             base::options(...future.oldOptions)
[01:29:12.661]             if (.Platform$OS.type == "windows") {
[01:29:12.661]                 old_names <- names(...future.oldEnvVars)
[01:29:12.661]                 envs <- base::Sys.getenv()
[01:29:12.661]                 names <- names(envs)
[01:29:12.661]                 common <- intersect(names, old_names)
[01:29:12.661]                 added <- setdiff(names, old_names)
[01:29:12.661]                 removed <- setdiff(old_names, names)
[01:29:12.661]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:12.661]                   envs[common]]
[01:29:12.661]                 NAMES <- toupper(changed)
[01:29:12.661]                 args <- list()
[01:29:12.661]                 for (kk in seq_along(NAMES)) {
[01:29:12.661]                   name <- changed[[kk]]
[01:29:12.661]                   NAME <- NAMES[[kk]]
[01:29:12.661]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:12.661]                     next
[01:29:12.661]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:12.661]                 }
[01:29:12.661]                 NAMES <- toupper(added)
[01:29:12.661]                 for (kk in seq_along(NAMES)) {
[01:29:12.661]                   name <- added[[kk]]
[01:29:12.661]                   NAME <- NAMES[[kk]]
[01:29:12.661]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:12.661]                     next
[01:29:12.661]                   args[[name]] <- ""
[01:29:12.661]                 }
[01:29:12.661]                 NAMES <- toupper(removed)
[01:29:12.661]                 for (kk in seq_along(NAMES)) {
[01:29:12.661]                   name <- removed[[kk]]
[01:29:12.661]                   NAME <- NAMES[[kk]]
[01:29:12.661]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:12.661]                     next
[01:29:12.661]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:12.661]                 }
[01:29:12.661]                 if (length(args) > 0) 
[01:29:12.661]                   base::do.call(base::Sys.setenv, args = args)
[01:29:12.661]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:12.661]             }
[01:29:12.661]             else {
[01:29:12.661]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:12.661]             }
[01:29:12.661]             {
[01:29:12.661]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:12.661]                   0L) {
[01:29:12.661]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:12.661]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:12.661]                   base::options(opts)
[01:29:12.661]                 }
[01:29:12.661]                 {
[01:29:12.661]                   {
[01:29:12.661]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:12.661]                     NULL
[01:29:12.661]                   }
[01:29:12.661]                   options(future.plan = NULL)
[01:29:12.661]                   if (is.na(NA_character_)) 
[01:29:12.661]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:12.661]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:12.661]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:12.661]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:12.661]                     envir = parent.frame()) 
[01:29:12.661]                   {
[01:29:12.661]                     if (is.function(workers)) 
[01:29:12.661]                       workers <- workers()
[01:29:12.661]                     workers <- structure(as.integer(workers), 
[01:29:12.661]                       class = class(workers))
[01:29:12.661]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:12.661]                       workers >= 1)
[01:29:12.661]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:12.661]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:12.661]                     }
[01:29:12.661]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:12.661]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:12.661]                       envir = envir)
[01:29:12.661]                     if (!future$lazy) 
[01:29:12.661]                       future <- run(future)
[01:29:12.661]                     invisible(future)
[01:29:12.661]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:12.661]                 }
[01:29:12.661]             }
[01:29:12.661]         }
[01:29:12.661]     })
[01:29:12.661]     if (TRUE) {
[01:29:12.661]         base::sink(type = "output", split = FALSE)
[01:29:12.661]         if (TRUE) {
[01:29:12.661]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:12.661]         }
[01:29:12.661]         else {
[01:29:12.661]             ...future.result["stdout"] <- base::list(NULL)
[01:29:12.661]         }
[01:29:12.661]         base::close(...future.stdout)
[01:29:12.661]         ...future.stdout <- NULL
[01:29:12.661]     }
[01:29:12.661]     ...future.result$conditions <- ...future.conditions
[01:29:12.661]     ...future.result$finished <- base::Sys.time()
[01:29:12.661]     ...future.result
[01:29:12.661] }
[01:29:12.667] Exporting 1 global objects (56 bytes) to cluster node #2 ...
[01:29:12.667] Exporting 'kk' (56 bytes) to cluster node #2 ...
[01:29:12.668] Exporting 'kk' (56 bytes) to cluster node #2 ... DONE
[01:29:12.668] Exporting 1 global objects (56 bytes) to cluster node #2 ... DONE
[01:29:12.668] MultisessionFuture started
[01:29:12.669] - Launch lazy future ... done
[01:29:12.669] run() for 'MultisessionFuture' ... done
[01:29:12.669] getGlobalsAndPackages() ...
[01:29:12.669] Searching for globals...
[01:29:12.670] - globals found: [3] '{', 'Sys.sleep', 'kk'
[01:29:12.670] Searching for globals ... DONE
[01:29:12.671] Resolving globals: FALSE
[01:29:12.671] The total size of the 1 globals is 56 bytes (56 bytes)
[01:29:12.672] The total size of the 1 globals exported for future expression ('{; Sys.sleep(0.1); kk; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'kk' (56 bytes of class 'numeric')
[01:29:12.672] - globals: [1] 'kk'
[01:29:12.672] 
[01:29:12.672] getGlobalsAndPackages() ... DONE
[01:29:12.673] run() for 'Future' ...
[01:29:12.673] - state: 'created'
[01:29:12.673] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:12.687] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:12.687] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:12.687]   - Field: 'node'
[01:29:12.687]   - Field: 'label'
[01:29:12.688]   - Field: 'local'
[01:29:12.688]   - Field: 'owner'
[01:29:12.688]   - Field: 'envir'
[01:29:12.688]   - Field: 'workers'
[01:29:12.688]   - Field: 'packages'
[01:29:12.689]   - Field: 'gc'
[01:29:12.689]   - Field: 'conditions'
[01:29:12.689]   - Field: 'persistent'
[01:29:12.689]   - Field: 'expr'
[01:29:12.689]   - Field: 'uuid'
[01:29:12.690]   - Field: 'seed'
[01:29:12.690]   - Field: 'version'
[01:29:12.690]   - Field: 'result'
[01:29:12.690]   - Field: 'asynchronous'
[01:29:12.690]   - Field: 'calls'
[01:29:12.690]   - Field: 'globals'
[01:29:12.691]   - Field: 'stdout'
[01:29:12.691]   - Field: 'earlySignal'
[01:29:12.691]   - Field: 'lazy'
[01:29:12.691]   - Field: 'state'
[01:29:12.691] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:12.691] - Launch lazy future ...
[01:29:12.692] Packages needed by the future expression (n = 0): <none>
[01:29:12.692] Packages needed by future strategies (n = 0): <none>
[01:29:12.693] {
[01:29:12.693]     {
[01:29:12.693]         {
[01:29:12.693]             ...future.startTime <- base::Sys.time()
[01:29:12.693]             {
[01:29:12.693]                 {
[01:29:12.693]                   {
[01:29:12.693]                     {
[01:29:12.693]                       base::local({
[01:29:12.693]                         has_future <- base::requireNamespace("future", 
[01:29:12.693]                           quietly = TRUE)
[01:29:12.693]                         if (has_future) {
[01:29:12.693]                           ns <- base::getNamespace("future")
[01:29:12.693]                           version <- ns[[".package"]][["version"]]
[01:29:12.693]                           if (is.null(version)) 
[01:29:12.693]                             version <- utils::packageVersion("future")
[01:29:12.693]                         }
[01:29:12.693]                         else {
[01:29:12.693]                           version <- NULL
[01:29:12.693]                         }
[01:29:12.693]                         if (!has_future || version < "1.8.0") {
[01:29:12.693]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:12.693]                             "", base::R.version$version.string), 
[01:29:12.693]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:12.693]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:12.693]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:12.693]                               "release", "version")], collapse = " "), 
[01:29:12.693]                             hostname = base::Sys.info()[["nodename"]])
[01:29:12.693]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:12.693]                             info)
[01:29:12.693]                           info <- base::paste(info, collapse = "; ")
[01:29:12.693]                           if (!has_future) {
[01:29:12.693]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:12.693]                               info)
[01:29:12.693]                           }
[01:29:12.693]                           else {
[01:29:12.693]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:12.693]                               info, version)
[01:29:12.693]                           }
[01:29:12.693]                           base::stop(msg)
[01:29:12.693]                         }
[01:29:12.693]                       })
[01:29:12.693]                     }
[01:29:12.693]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:12.693]                     base::options(mc.cores = 1L)
[01:29:12.693]                   }
[01:29:12.693]                   options(future.plan = NULL)
[01:29:12.693]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:12.693]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:12.693]                 }
[01:29:12.693]                 ...future.workdir <- getwd()
[01:29:12.693]             }
[01:29:12.693]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:12.693]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:12.693]         }
[01:29:12.693]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:12.693]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:12.693]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:12.693]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:12.693]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:12.693]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:12.693]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:12.693]             base::names(...future.oldOptions))
[01:29:12.693]     }
[01:29:12.693]     if (FALSE) {
[01:29:12.693]     }
[01:29:12.693]     else {
[01:29:12.693]         if (TRUE) {
[01:29:12.693]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:12.693]                 open = "w")
[01:29:12.693]         }
[01:29:12.693]         else {
[01:29:12.693]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:12.693]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:12.693]         }
[01:29:12.693]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:12.693]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:12.693]             base::sink(type = "output", split = FALSE)
[01:29:12.693]             base::close(...future.stdout)
[01:29:12.693]         }, add = TRUE)
[01:29:12.693]     }
[01:29:12.693]     ...future.frame <- base::sys.nframe()
[01:29:12.693]     ...future.conditions <- base::list()
[01:29:12.693]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:12.693]     if (FALSE) {
[01:29:12.693]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:12.693]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:12.693]     }
[01:29:12.693]     ...future.result <- base::tryCatch({
[01:29:12.693]         base::withCallingHandlers({
[01:29:12.693]             ...future.value <- base::withVisible(base::local({
[01:29:12.693]                 ...future.makeSendCondition <- base::local({
[01:29:12.693]                   sendCondition <- NULL
[01:29:12.693]                   function(frame = 1L) {
[01:29:12.693]                     if (is.function(sendCondition)) 
[01:29:12.693]                       return(sendCondition)
[01:29:12.693]                     ns <- getNamespace("parallel")
[01:29:12.693]                     if (exists("sendData", mode = "function", 
[01:29:12.693]                       envir = ns)) {
[01:29:12.693]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:12.693]                         envir = ns)
[01:29:12.693]                       envir <- sys.frame(frame)
[01:29:12.693]                       master <- NULL
[01:29:12.693]                       while (!identical(envir, .GlobalEnv) && 
[01:29:12.693]                         !identical(envir, emptyenv())) {
[01:29:12.693]                         if (exists("master", mode = "list", envir = envir, 
[01:29:12.693]                           inherits = FALSE)) {
[01:29:12.693]                           master <- get("master", mode = "list", 
[01:29:12.693]                             envir = envir, inherits = FALSE)
[01:29:12.693]                           if (inherits(master, c("SOCKnode", 
[01:29:12.693]                             "SOCK0node"))) {
[01:29:12.693]                             sendCondition <<- function(cond) {
[01:29:12.693]                               data <- list(type = "VALUE", value = cond, 
[01:29:12.693]                                 success = TRUE)
[01:29:12.693]                               parallel_sendData(master, data)
[01:29:12.693]                             }
[01:29:12.693]                             return(sendCondition)
[01:29:12.693]                           }
[01:29:12.693]                         }
[01:29:12.693]                         frame <- frame + 1L
[01:29:12.693]                         envir <- sys.frame(frame)
[01:29:12.693]                       }
[01:29:12.693]                     }
[01:29:12.693]                     sendCondition <<- function(cond) NULL
[01:29:12.693]                   }
[01:29:12.693]                 })
[01:29:12.693]                 withCallingHandlers({
[01:29:12.693]                   {
[01:29:12.693]                     Sys.sleep(0.1)
[01:29:12.693]                     kk
[01:29:12.693]                   }
[01:29:12.693]                 }, immediateCondition = function(cond) {
[01:29:12.693]                   sendCondition <- ...future.makeSendCondition()
[01:29:12.693]                   sendCondition(cond)
[01:29:12.693]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:12.693]                   {
[01:29:12.693]                     inherits <- base::inherits
[01:29:12.693]                     invokeRestart <- base::invokeRestart
[01:29:12.693]                     is.null <- base::is.null
[01:29:12.693]                     muffled <- FALSE
[01:29:12.693]                     if (inherits(cond, "message")) {
[01:29:12.693]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:12.693]                       if (muffled) 
[01:29:12.693]                         invokeRestart("muffleMessage")
[01:29:12.693]                     }
[01:29:12.693]                     else if (inherits(cond, "warning")) {
[01:29:12.693]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:12.693]                       if (muffled) 
[01:29:12.693]                         invokeRestart("muffleWarning")
[01:29:12.693]                     }
[01:29:12.693]                     else if (inherits(cond, "condition")) {
[01:29:12.693]                       if (!is.null(pattern)) {
[01:29:12.693]                         computeRestarts <- base::computeRestarts
[01:29:12.693]                         grepl <- base::grepl
[01:29:12.693]                         restarts <- computeRestarts(cond)
[01:29:12.693]                         for (restart in restarts) {
[01:29:12.693]                           name <- restart$name
[01:29:12.693]                           if (is.null(name)) 
[01:29:12.693]                             next
[01:29:12.693]                           if (!grepl(pattern, name)) 
[01:29:12.693]                             next
[01:29:12.693]                           invokeRestart(restart)
[01:29:12.693]                           muffled <- TRUE
[01:29:12.693]                           break
[01:29:12.693]                         }
[01:29:12.693]                       }
[01:29:12.693]                     }
[01:29:12.693]                     invisible(muffled)
[01:29:12.693]                   }
[01:29:12.693]                   muffleCondition(cond)
[01:29:12.693]                 })
[01:29:12.693]             }))
[01:29:12.693]             future::FutureResult(value = ...future.value$value, 
[01:29:12.693]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:12.693]                   ...future.rng), globalenv = if (FALSE) 
[01:29:12.693]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:12.693]                     ...future.globalenv.names))
[01:29:12.693]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:12.693]         }, condition = base::local({
[01:29:12.693]             c <- base::c
[01:29:12.693]             inherits <- base::inherits
[01:29:12.693]             invokeRestart <- base::invokeRestart
[01:29:12.693]             length <- base::length
[01:29:12.693]             list <- base::list
[01:29:12.693]             seq.int <- base::seq.int
[01:29:12.693]             signalCondition <- base::signalCondition
[01:29:12.693]             sys.calls <- base::sys.calls
[01:29:12.693]             `[[` <- base::`[[`
[01:29:12.693]             `+` <- base::`+`
[01:29:12.693]             `<<-` <- base::`<<-`
[01:29:12.693]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:12.693]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:12.693]                   3L)]
[01:29:12.693]             }
[01:29:12.693]             function(cond) {
[01:29:12.693]                 is_error <- inherits(cond, "error")
[01:29:12.693]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:12.693]                   NULL)
[01:29:12.693]                 if (is_error) {
[01:29:12.693]                   sessionInformation <- function() {
[01:29:12.693]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:12.693]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:12.693]                       search = base::search(), system = base::Sys.info())
[01:29:12.693]                   }
[01:29:12.693]                   ...future.conditions[[length(...future.conditions) + 
[01:29:12.693]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:12.693]                     cond$call), session = sessionInformation(), 
[01:29:12.693]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:12.693]                   signalCondition(cond)
[01:29:12.693]                 }
[01:29:12.693]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:12.693]                 "immediateCondition"))) {
[01:29:12.693]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:12.693]                   ...future.conditions[[length(...future.conditions) + 
[01:29:12.693]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:12.693]                   if (TRUE && !signal) {
[01:29:12.693]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:12.693]                     {
[01:29:12.693]                       inherits <- base::inherits
[01:29:12.693]                       invokeRestart <- base::invokeRestart
[01:29:12.693]                       is.null <- base::is.null
[01:29:12.693]                       muffled <- FALSE
[01:29:12.693]                       if (inherits(cond, "message")) {
[01:29:12.693]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:12.693]                         if (muffled) 
[01:29:12.693]                           invokeRestart("muffleMessage")
[01:29:12.693]                       }
[01:29:12.693]                       else if (inherits(cond, "warning")) {
[01:29:12.693]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:12.693]                         if (muffled) 
[01:29:12.693]                           invokeRestart("muffleWarning")
[01:29:12.693]                       }
[01:29:12.693]                       else if (inherits(cond, "condition")) {
[01:29:12.693]                         if (!is.null(pattern)) {
[01:29:12.693]                           computeRestarts <- base::computeRestarts
[01:29:12.693]                           grepl <- base::grepl
[01:29:12.693]                           restarts <- computeRestarts(cond)
[01:29:12.693]                           for (restart in restarts) {
[01:29:12.693]                             name <- restart$name
[01:29:12.693]                             if (is.null(name)) 
[01:29:12.693]                               next
[01:29:12.693]                             if (!grepl(pattern, name)) 
[01:29:12.693]                               next
[01:29:12.693]                             invokeRestart(restart)
[01:29:12.693]                             muffled <- TRUE
[01:29:12.693]                             break
[01:29:12.693]                           }
[01:29:12.693]                         }
[01:29:12.693]                       }
[01:29:12.693]                       invisible(muffled)
[01:29:12.693]                     }
[01:29:12.693]                     muffleCondition(cond, pattern = "^muffle")
[01:29:12.693]                   }
[01:29:12.693]                 }
[01:29:12.693]                 else {
[01:29:12.693]                   if (TRUE) {
[01:29:12.693]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:12.693]                     {
[01:29:12.693]                       inherits <- base::inherits
[01:29:12.693]                       invokeRestart <- base::invokeRestart
[01:29:12.693]                       is.null <- base::is.null
[01:29:12.693]                       muffled <- FALSE
[01:29:12.693]                       if (inherits(cond, "message")) {
[01:29:12.693]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:12.693]                         if (muffled) 
[01:29:12.693]                           invokeRestart("muffleMessage")
[01:29:12.693]                       }
[01:29:12.693]                       else if (inherits(cond, "warning")) {
[01:29:12.693]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:12.693]                         if (muffled) 
[01:29:12.693]                           invokeRestart("muffleWarning")
[01:29:12.693]                       }
[01:29:12.693]                       else if (inherits(cond, "condition")) {
[01:29:12.693]                         if (!is.null(pattern)) {
[01:29:12.693]                           computeRestarts <- base::computeRestarts
[01:29:12.693]                           grepl <- base::grepl
[01:29:12.693]                           restarts <- computeRestarts(cond)
[01:29:12.693]                           for (restart in restarts) {
[01:29:12.693]                             name <- restart$name
[01:29:12.693]                             if (is.null(name)) 
[01:29:12.693]                               next
[01:29:12.693]                             if (!grepl(pattern, name)) 
[01:29:12.693]                               next
[01:29:12.693]                             invokeRestart(restart)
[01:29:12.693]                             muffled <- TRUE
[01:29:12.693]                             break
[01:29:12.693]                           }
[01:29:12.693]                         }
[01:29:12.693]                       }
[01:29:12.693]                       invisible(muffled)
[01:29:12.693]                     }
[01:29:12.693]                     muffleCondition(cond, pattern = "^muffle")
[01:29:12.693]                   }
[01:29:12.693]                 }
[01:29:12.693]             }
[01:29:12.693]         }))
[01:29:12.693]     }, error = function(ex) {
[01:29:12.693]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:12.693]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:12.693]                 ...future.rng), started = ...future.startTime, 
[01:29:12.693]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:12.693]             version = "1.8"), class = "FutureResult")
[01:29:12.693]     }, finally = {
[01:29:12.693]         if (!identical(...future.workdir, getwd())) 
[01:29:12.693]             setwd(...future.workdir)
[01:29:12.693]         {
[01:29:12.693]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:12.693]                 ...future.oldOptions$nwarnings <- NULL
[01:29:12.693]             }
[01:29:12.693]             base::options(...future.oldOptions)
[01:29:12.693]             if (.Platform$OS.type == "windows") {
[01:29:12.693]                 old_names <- names(...future.oldEnvVars)
[01:29:12.693]                 envs <- base::Sys.getenv()
[01:29:12.693]                 names <- names(envs)
[01:29:12.693]                 common <- intersect(names, old_names)
[01:29:12.693]                 added <- setdiff(names, old_names)
[01:29:12.693]                 removed <- setdiff(old_names, names)
[01:29:12.693]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:12.693]                   envs[common]]
[01:29:12.693]                 NAMES <- toupper(changed)
[01:29:12.693]                 args <- list()
[01:29:12.693]                 for (kk in seq_along(NAMES)) {
[01:29:12.693]                   name <- changed[[kk]]
[01:29:12.693]                   NAME <- NAMES[[kk]]
[01:29:12.693]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:12.693]                     next
[01:29:12.693]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:12.693]                 }
[01:29:12.693]                 NAMES <- toupper(added)
[01:29:12.693]                 for (kk in seq_along(NAMES)) {
[01:29:12.693]                   name <- added[[kk]]
[01:29:12.693]                   NAME <- NAMES[[kk]]
[01:29:12.693]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:12.693]                     next
[01:29:12.693]                   args[[name]] <- ""
[01:29:12.693]                 }
[01:29:12.693]                 NAMES <- toupper(removed)
[01:29:12.693]                 for (kk in seq_along(NAMES)) {
[01:29:12.693]                   name <- removed[[kk]]
[01:29:12.693]                   NAME <- NAMES[[kk]]
[01:29:12.693]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:12.693]                     next
[01:29:12.693]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:12.693]                 }
[01:29:12.693]                 if (length(args) > 0) 
[01:29:12.693]                   base::do.call(base::Sys.setenv, args = args)
[01:29:12.693]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:12.693]             }
[01:29:12.693]             else {
[01:29:12.693]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:12.693]             }
[01:29:12.693]             {
[01:29:12.693]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:12.693]                   0L) {
[01:29:12.693]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:12.693]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:12.693]                   base::options(opts)
[01:29:12.693]                 }
[01:29:12.693]                 {
[01:29:12.693]                   {
[01:29:12.693]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:12.693]                     NULL
[01:29:12.693]                   }
[01:29:12.693]                   options(future.plan = NULL)
[01:29:12.693]                   if (is.na(NA_character_)) 
[01:29:12.693]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:12.693]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:12.693]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:12.693]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:12.693]                     envir = parent.frame()) 
[01:29:12.693]                   {
[01:29:12.693]                     if (is.function(workers)) 
[01:29:12.693]                       workers <- workers()
[01:29:12.693]                     workers <- structure(as.integer(workers), 
[01:29:12.693]                       class = class(workers))
[01:29:12.693]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:12.693]                       workers >= 1)
[01:29:12.693]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:12.693]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:12.693]                     }
[01:29:12.693]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:12.693]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:12.693]                       envir = envir)
[01:29:12.693]                     if (!future$lazy) 
[01:29:12.693]                       future <- run(future)
[01:29:12.693]                     invisible(future)
[01:29:12.693]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:12.693]                 }
[01:29:12.693]             }
[01:29:12.693]         }
[01:29:12.693]     })
[01:29:12.693]     if (TRUE) {
[01:29:12.693]         base::sink(type = "output", split = FALSE)
[01:29:12.693]         if (TRUE) {
[01:29:12.693]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:12.693]         }
[01:29:12.693]         else {
[01:29:12.693]             ...future.result["stdout"] <- base::list(NULL)
[01:29:12.693]         }
[01:29:12.693]         base::close(...future.stdout)
[01:29:12.693]         ...future.stdout <- NULL
[01:29:12.693]     }
[01:29:12.693]     ...future.result$conditions <- ...future.conditions
[01:29:12.693]     ...future.result$finished <- base::Sys.time()
[01:29:12.693]     ...future.result
[01:29:12.693] }
[01:29:12.698] Poll #1 (0): usedNodes() = 2, workers = 2
[01:29:12.769] receiveMessageFromWorker() for ClusterFuture ...
[01:29:12.769] - Validating connection of MultisessionFuture
[01:29:12.769] - received message: FutureResult
[01:29:12.770] - Received FutureResult
[01:29:12.770] - Erased future from FutureRegistry
[01:29:12.770] result() for ClusterFuture ...
[01:29:12.770] - result already collected: FutureResult
[01:29:12.770] result() for ClusterFuture ... done
[01:29:12.771] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:12.771] result() for ClusterFuture ...
[01:29:12.771] - result already collected: FutureResult
[01:29:12.771] result() for ClusterFuture ... done
[01:29:12.771] result() for ClusterFuture ...
[01:29:12.771] - result already collected: FutureResult
[01:29:12.772] result() for ClusterFuture ... done
[01:29:12.772] Exporting 1 global objects (56 bytes) to cluster node #1 ...
[01:29:12.773] Exporting 'kk' (56 bytes) to cluster node #1 ...
[01:29:12.773] Exporting 'kk' (56 bytes) to cluster node #1 ... DONE
[01:29:12.773] Exporting 1 global objects (56 bytes) to cluster node #1 ... DONE
[01:29:12.774] MultisessionFuture started
[01:29:12.774] - Launch lazy future ... done
[01:29:12.774] run() for 'MultisessionFuture' ... done
[01:29:12.775] resolve() on list ...
[01:29:12.775]  recursive: 0
[01:29:12.775]  length: 3
[01:29:12.775] 
[01:29:12.775] Future #1
[01:29:12.776]  length: 2 (resolved future 1)
[01:29:12.802] receiveMessageFromWorker() for ClusterFuture ...
[01:29:12.803] - Validating connection of MultisessionFuture
[01:29:12.803] - received message: FutureResult
[01:29:12.803] - Received FutureResult
[01:29:12.803] - Erased future from FutureRegistry
[01:29:12.804] result() for ClusterFuture ...
[01:29:12.804] - result already collected: FutureResult
[01:29:12.804] result() for ClusterFuture ... done
[01:29:12.804] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:12.804] Future #2
[01:29:12.804]  length: 1 (resolved future 2)
[01:29:12.891] receiveMessageFromWorker() for ClusterFuture ...
[01:29:12.892] - Validating connection of MultisessionFuture
[01:29:12.892] - received message: FutureResult
[01:29:12.892] - Received FutureResult
[01:29:12.892] - Erased future from FutureRegistry
[01:29:12.893] result() for ClusterFuture ...
[01:29:12.893] - result already collected: FutureResult
[01:29:12.893] result() for ClusterFuture ... done
[01:29:12.893] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:12.893] Future #3
[01:29:12.893]  length: 0 (resolved future 3)
[01:29:12.894] resolve() on list ... DONE
[01:29:12.894] getGlobalsAndPackages() ...
[01:29:12.894] Searching for globals...
[01:29:12.895] - globals found: [3] '{', 'Sys.sleep', 'kk'
[01:29:12.895] Searching for globals ... DONE
[01:29:12.896] Resolving globals: FALSE
[01:29:12.896] The total size of the 1 globals is 56 bytes (56 bytes)
[01:29:12.897] The total size of the 1 globals exported for future expression ('{; Sys.sleep(0.1); kk; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'kk' (56 bytes of class 'numeric')
[01:29:12.897] - globals: [1] 'kk'
[01:29:12.897] 
[01:29:12.897] getGlobalsAndPackages() ... DONE
[01:29:12.898] getGlobalsAndPackages() ...
[01:29:12.898] Searching for globals...
[01:29:12.899] - globals found: [3] '{', 'Sys.sleep', 'kk'
[01:29:12.899] Searching for globals ... DONE
[01:29:12.899] Resolving globals: FALSE
[01:29:12.900] The total size of the 1 globals is 56 bytes (56 bytes)
[01:29:12.900] The total size of the 1 globals exported for future expression ('{; Sys.sleep(0.1); kk; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'kk' (56 bytes of class 'numeric')
[01:29:12.901] - globals: [1] 'kk'
[01:29:12.901] 
[01:29:12.901] getGlobalsAndPackages() ... DONE
[01:29:12.901] getGlobalsAndPackages() ...
[01:29:12.901] Searching for globals...
[01:29:12.903] - globals found: [3] '{', 'Sys.sleep', 'kk'
[01:29:12.903] Searching for globals ... DONE
[01:29:12.903] Resolving globals: FALSE
[01:29:12.903] The total size of the 1 globals is 56 bytes (56 bytes)
[01:29:12.904] The total size of the 1 globals exported for future expression ('{; Sys.sleep(0.1); kk; }') is 56 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'kk' (56 bytes of class 'numeric')
[01:29:12.904] - globals: [1] 'kk'
[01:29:12.904] 
[01:29:12.904] getGlobalsAndPackages() ... DONE
[01:29:12.908] resolve() on list ...
[01:29:12.908]  recursive: 0
[01:29:12.908]  length: 3
[01:29:12.908] 
[01:29:12.909] run() for 'Future' ...
[01:29:12.909] - state: 'created'
[01:29:12.909] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:12.923] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:12.924] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:12.924]   - Field: 'node'
[01:29:12.924]   - Field: 'label'
[01:29:12.924]   - Field: 'local'
[01:29:12.924]   - Field: 'owner'
[01:29:12.925]   - Field: 'envir'
[01:29:12.925]   - Field: 'workers'
[01:29:12.925]   - Field: 'packages'
[01:29:12.925]   - Field: 'gc'
[01:29:12.925]   - Field: 'conditions'
[01:29:12.925]   - Field: 'persistent'
[01:29:12.926]   - Field: 'expr'
[01:29:12.926]   - Field: 'uuid'
[01:29:12.926]   - Field: 'seed'
[01:29:12.926]   - Field: 'version'
[01:29:12.926]   - Field: 'result'
[01:29:12.926]   - Field: 'asynchronous'
[01:29:12.927]   - Field: 'calls'
[01:29:12.927]   - Field: 'globals'
[01:29:12.927]   - Field: 'stdout'
[01:29:12.927]   - Field: 'earlySignal'
[01:29:12.927]   - Field: 'lazy'
[01:29:12.927]   - Field: 'state'
[01:29:12.928] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:12.928] - Launch lazy future ...
[01:29:12.928] Packages needed by the future expression (n = 0): <none>
[01:29:12.928] Packages needed by future strategies (n = 0): <none>
[01:29:12.929] {
[01:29:12.929]     {
[01:29:12.929]         {
[01:29:12.929]             ...future.startTime <- base::Sys.time()
[01:29:12.929]             {
[01:29:12.929]                 {
[01:29:12.929]                   {
[01:29:12.929]                     {
[01:29:12.929]                       base::local({
[01:29:12.929]                         has_future <- base::requireNamespace("future", 
[01:29:12.929]                           quietly = TRUE)
[01:29:12.929]                         if (has_future) {
[01:29:12.929]                           ns <- base::getNamespace("future")
[01:29:12.929]                           version <- ns[[".package"]][["version"]]
[01:29:12.929]                           if (is.null(version)) 
[01:29:12.929]                             version <- utils::packageVersion("future")
[01:29:12.929]                         }
[01:29:12.929]                         else {
[01:29:12.929]                           version <- NULL
[01:29:12.929]                         }
[01:29:12.929]                         if (!has_future || version < "1.8.0") {
[01:29:12.929]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:12.929]                             "", base::R.version$version.string), 
[01:29:12.929]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:12.929]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:12.929]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:12.929]                               "release", "version")], collapse = " "), 
[01:29:12.929]                             hostname = base::Sys.info()[["nodename"]])
[01:29:12.929]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:12.929]                             info)
[01:29:12.929]                           info <- base::paste(info, collapse = "; ")
[01:29:12.929]                           if (!has_future) {
[01:29:12.929]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:12.929]                               info)
[01:29:12.929]                           }
[01:29:12.929]                           else {
[01:29:12.929]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:12.929]                               info, version)
[01:29:12.929]                           }
[01:29:12.929]                           base::stop(msg)
[01:29:12.929]                         }
[01:29:12.929]                       })
[01:29:12.929]                     }
[01:29:12.929]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:12.929]                     base::options(mc.cores = 1L)
[01:29:12.929]                   }
[01:29:12.929]                   options(future.plan = NULL)
[01:29:12.929]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:12.929]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:12.929]                 }
[01:29:12.929]                 ...future.workdir <- getwd()
[01:29:12.929]             }
[01:29:12.929]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:12.929]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:12.929]         }
[01:29:12.929]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:12.929]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:12.929]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:12.929]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:12.929]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:12.929]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:12.929]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:12.929]             base::names(...future.oldOptions))
[01:29:12.929]     }
[01:29:12.929]     if (FALSE) {
[01:29:12.929]     }
[01:29:12.929]     else {
[01:29:12.929]         if (TRUE) {
[01:29:12.929]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:12.929]                 open = "w")
[01:29:12.929]         }
[01:29:12.929]         else {
[01:29:12.929]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:12.929]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:12.929]         }
[01:29:12.929]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:12.929]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:12.929]             base::sink(type = "output", split = FALSE)
[01:29:12.929]             base::close(...future.stdout)
[01:29:12.929]         }, add = TRUE)
[01:29:12.929]     }
[01:29:12.929]     ...future.frame <- base::sys.nframe()
[01:29:12.929]     ...future.conditions <- base::list()
[01:29:12.929]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:12.929]     if (FALSE) {
[01:29:12.929]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:12.929]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:12.929]     }
[01:29:12.929]     ...future.result <- base::tryCatch({
[01:29:12.929]         base::withCallingHandlers({
[01:29:12.929]             ...future.value <- base::withVisible(base::local({
[01:29:12.929]                 ...future.makeSendCondition <- base::local({
[01:29:12.929]                   sendCondition <- NULL
[01:29:12.929]                   function(frame = 1L) {
[01:29:12.929]                     if (is.function(sendCondition)) 
[01:29:12.929]                       return(sendCondition)
[01:29:12.929]                     ns <- getNamespace("parallel")
[01:29:12.929]                     if (exists("sendData", mode = "function", 
[01:29:12.929]                       envir = ns)) {
[01:29:12.929]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:12.929]                         envir = ns)
[01:29:12.929]                       envir <- sys.frame(frame)
[01:29:12.929]                       master <- NULL
[01:29:12.929]                       while (!identical(envir, .GlobalEnv) && 
[01:29:12.929]                         !identical(envir, emptyenv())) {
[01:29:12.929]                         if (exists("master", mode = "list", envir = envir, 
[01:29:12.929]                           inherits = FALSE)) {
[01:29:12.929]                           master <- get("master", mode = "list", 
[01:29:12.929]                             envir = envir, inherits = FALSE)
[01:29:12.929]                           if (inherits(master, c("SOCKnode", 
[01:29:12.929]                             "SOCK0node"))) {
[01:29:12.929]                             sendCondition <<- function(cond) {
[01:29:12.929]                               data <- list(type = "VALUE", value = cond, 
[01:29:12.929]                                 success = TRUE)
[01:29:12.929]                               parallel_sendData(master, data)
[01:29:12.929]                             }
[01:29:12.929]                             return(sendCondition)
[01:29:12.929]                           }
[01:29:12.929]                         }
[01:29:12.929]                         frame <- frame + 1L
[01:29:12.929]                         envir <- sys.frame(frame)
[01:29:12.929]                       }
[01:29:12.929]                     }
[01:29:12.929]                     sendCondition <<- function(cond) NULL
[01:29:12.929]                   }
[01:29:12.929]                 })
[01:29:12.929]                 withCallingHandlers({
[01:29:12.929]                   {
[01:29:12.929]                     Sys.sleep(0.1)
[01:29:12.929]                     kk
[01:29:12.929]                   }
[01:29:12.929]                 }, immediateCondition = function(cond) {
[01:29:12.929]                   sendCondition <- ...future.makeSendCondition()
[01:29:12.929]                   sendCondition(cond)
[01:29:12.929]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:12.929]                   {
[01:29:12.929]                     inherits <- base::inherits
[01:29:12.929]                     invokeRestart <- base::invokeRestart
[01:29:12.929]                     is.null <- base::is.null
[01:29:12.929]                     muffled <- FALSE
[01:29:12.929]                     if (inherits(cond, "message")) {
[01:29:12.929]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:12.929]                       if (muffled) 
[01:29:12.929]                         invokeRestart("muffleMessage")
[01:29:12.929]                     }
[01:29:12.929]                     else if (inherits(cond, "warning")) {
[01:29:12.929]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:12.929]                       if (muffled) 
[01:29:12.929]                         invokeRestart("muffleWarning")
[01:29:12.929]                     }
[01:29:12.929]                     else if (inherits(cond, "condition")) {
[01:29:12.929]                       if (!is.null(pattern)) {
[01:29:12.929]                         computeRestarts <- base::computeRestarts
[01:29:12.929]                         grepl <- base::grepl
[01:29:12.929]                         restarts <- computeRestarts(cond)
[01:29:12.929]                         for (restart in restarts) {
[01:29:12.929]                           name <- restart$name
[01:29:12.929]                           if (is.null(name)) 
[01:29:12.929]                             next
[01:29:12.929]                           if (!grepl(pattern, name)) 
[01:29:12.929]                             next
[01:29:12.929]                           invokeRestart(restart)
[01:29:12.929]                           muffled <- TRUE
[01:29:12.929]                           break
[01:29:12.929]                         }
[01:29:12.929]                       }
[01:29:12.929]                     }
[01:29:12.929]                     invisible(muffled)
[01:29:12.929]                   }
[01:29:12.929]                   muffleCondition(cond)
[01:29:12.929]                 })
[01:29:12.929]             }))
[01:29:12.929]             future::FutureResult(value = ...future.value$value, 
[01:29:12.929]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:12.929]                   ...future.rng), globalenv = if (FALSE) 
[01:29:12.929]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:12.929]                     ...future.globalenv.names))
[01:29:12.929]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:12.929]         }, condition = base::local({
[01:29:12.929]             c <- base::c
[01:29:12.929]             inherits <- base::inherits
[01:29:12.929]             invokeRestart <- base::invokeRestart
[01:29:12.929]             length <- base::length
[01:29:12.929]             list <- base::list
[01:29:12.929]             seq.int <- base::seq.int
[01:29:12.929]             signalCondition <- base::signalCondition
[01:29:12.929]             sys.calls <- base::sys.calls
[01:29:12.929]             `[[` <- base::`[[`
[01:29:12.929]             `+` <- base::`+`
[01:29:12.929]             `<<-` <- base::`<<-`
[01:29:12.929]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:12.929]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:12.929]                   3L)]
[01:29:12.929]             }
[01:29:12.929]             function(cond) {
[01:29:12.929]                 is_error <- inherits(cond, "error")
[01:29:12.929]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:12.929]                   NULL)
[01:29:12.929]                 if (is_error) {
[01:29:12.929]                   sessionInformation <- function() {
[01:29:12.929]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:12.929]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:12.929]                       search = base::search(), system = base::Sys.info())
[01:29:12.929]                   }
[01:29:12.929]                   ...future.conditions[[length(...future.conditions) + 
[01:29:12.929]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:12.929]                     cond$call), session = sessionInformation(), 
[01:29:12.929]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:12.929]                   signalCondition(cond)
[01:29:12.929]                 }
[01:29:12.929]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:12.929]                 "immediateCondition"))) {
[01:29:12.929]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:12.929]                   ...future.conditions[[length(...future.conditions) + 
[01:29:12.929]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:12.929]                   if (TRUE && !signal) {
[01:29:12.929]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:12.929]                     {
[01:29:12.929]                       inherits <- base::inherits
[01:29:12.929]                       invokeRestart <- base::invokeRestart
[01:29:12.929]                       is.null <- base::is.null
[01:29:12.929]                       muffled <- FALSE
[01:29:12.929]                       if (inherits(cond, "message")) {
[01:29:12.929]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:12.929]                         if (muffled) 
[01:29:12.929]                           invokeRestart("muffleMessage")
[01:29:12.929]                       }
[01:29:12.929]                       else if (inherits(cond, "warning")) {
[01:29:12.929]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:12.929]                         if (muffled) 
[01:29:12.929]                           invokeRestart("muffleWarning")
[01:29:12.929]                       }
[01:29:12.929]                       else if (inherits(cond, "condition")) {
[01:29:12.929]                         if (!is.null(pattern)) {
[01:29:12.929]                           computeRestarts <- base::computeRestarts
[01:29:12.929]                           grepl <- base::grepl
[01:29:12.929]                           restarts <- computeRestarts(cond)
[01:29:12.929]                           for (restart in restarts) {
[01:29:12.929]                             name <- restart$name
[01:29:12.929]                             if (is.null(name)) 
[01:29:12.929]                               next
[01:29:12.929]                             if (!grepl(pattern, name)) 
[01:29:12.929]                               next
[01:29:12.929]                             invokeRestart(restart)
[01:29:12.929]                             muffled <- TRUE
[01:29:12.929]                             break
[01:29:12.929]                           }
[01:29:12.929]                         }
[01:29:12.929]                       }
[01:29:12.929]                       invisible(muffled)
[01:29:12.929]                     }
[01:29:12.929]                     muffleCondition(cond, pattern = "^muffle")
[01:29:12.929]                   }
[01:29:12.929]                 }
[01:29:12.929]                 else {
[01:29:12.929]                   if (TRUE) {
[01:29:12.929]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:12.929]                     {
[01:29:12.929]                       inherits <- base::inherits
[01:29:12.929]                       invokeRestart <- base::invokeRestart
[01:29:12.929]                       is.null <- base::is.null
[01:29:12.929]                       muffled <- FALSE
[01:29:12.929]                       if (inherits(cond, "message")) {
[01:29:12.929]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:12.929]                         if (muffled) 
[01:29:12.929]                           invokeRestart("muffleMessage")
[01:29:12.929]                       }
[01:29:12.929]                       else if (inherits(cond, "warning")) {
[01:29:12.929]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:12.929]                         if (muffled) 
[01:29:12.929]                           invokeRestart("muffleWarning")
[01:29:12.929]                       }
[01:29:12.929]                       else if (inherits(cond, "condition")) {
[01:29:12.929]                         if (!is.null(pattern)) {
[01:29:12.929]                           computeRestarts <- base::computeRestarts
[01:29:12.929]                           grepl <- base::grepl
[01:29:12.929]                           restarts <- computeRestarts(cond)
[01:29:12.929]                           for (restart in restarts) {
[01:29:12.929]                             name <- restart$name
[01:29:12.929]                             if (is.null(name)) 
[01:29:12.929]                               next
[01:29:12.929]                             if (!grepl(pattern, name)) 
[01:29:12.929]                               next
[01:29:12.929]                             invokeRestart(restart)
[01:29:12.929]                             muffled <- TRUE
[01:29:12.929]                             break
[01:29:12.929]                           }
[01:29:12.929]                         }
[01:29:12.929]                       }
[01:29:12.929]                       invisible(muffled)
[01:29:12.929]                     }
[01:29:12.929]                     muffleCondition(cond, pattern = "^muffle")
[01:29:12.929]                   }
[01:29:12.929]                 }
[01:29:12.929]             }
[01:29:12.929]         }))
[01:29:12.929]     }, error = function(ex) {
[01:29:12.929]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:12.929]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:12.929]                 ...future.rng), started = ...future.startTime, 
[01:29:12.929]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:12.929]             version = "1.8"), class = "FutureResult")
[01:29:12.929]     }, finally = {
[01:29:12.929]         if (!identical(...future.workdir, getwd())) 
[01:29:12.929]             setwd(...future.workdir)
[01:29:12.929]         {
[01:29:12.929]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:12.929]                 ...future.oldOptions$nwarnings <- NULL
[01:29:12.929]             }
[01:29:12.929]             base::options(...future.oldOptions)
[01:29:12.929]             if (.Platform$OS.type == "windows") {
[01:29:12.929]                 old_names <- names(...future.oldEnvVars)
[01:29:12.929]                 envs <- base::Sys.getenv()
[01:29:12.929]                 names <- names(envs)
[01:29:12.929]                 common <- intersect(names, old_names)
[01:29:12.929]                 added <- setdiff(names, old_names)
[01:29:12.929]                 removed <- setdiff(old_names, names)
[01:29:12.929]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:12.929]                   envs[common]]
[01:29:12.929]                 NAMES <- toupper(changed)
[01:29:12.929]                 args <- list()
[01:29:12.929]                 for (kk in seq_along(NAMES)) {
[01:29:12.929]                   name <- changed[[kk]]
[01:29:12.929]                   NAME <- NAMES[[kk]]
[01:29:12.929]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:12.929]                     next
[01:29:12.929]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:12.929]                 }
[01:29:12.929]                 NAMES <- toupper(added)
[01:29:12.929]                 for (kk in seq_along(NAMES)) {
[01:29:12.929]                   name <- added[[kk]]
[01:29:12.929]                   NAME <- NAMES[[kk]]
[01:29:12.929]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:12.929]                     next
[01:29:12.929]                   args[[name]] <- ""
[01:29:12.929]                 }
[01:29:12.929]                 NAMES <- toupper(removed)
[01:29:12.929]                 for (kk in seq_along(NAMES)) {
[01:29:12.929]                   name <- removed[[kk]]
[01:29:12.929]                   NAME <- NAMES[[kk]]
[01:29:12.929]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:12.929]                     next
[01:29:12.929]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:12.929]                 }
[01:29:12.929]                 if (length(args) > 0) 
[01:29:12.929]                   base::do.call(base::Sys.setenv, args = args)
[01:29:12.929]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:12.929]             }
[01:29:12.929]             else {
[01:29:12.929]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:12.929]             }
[01:29:12.929]             {
[01:29:12.929]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:12.929]                   0L) {
[01:29:12.929]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:12.929]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:12.929]                   base::options(opts)
[01:29:12.929]                 }
[01:29:12.929]                 {
[01:29:12.929]                   {
[01:29:12.929]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:12.929]                     NULL
[01:29:12.929]                   }
[01:29:12.929]                   options(future.plan = NULL)
[01:29:12.929]                   if (is.na(NA_character_)) 
[01:29:12.929]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:12.929]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:12.929]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:12.929]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:12.929]                     envir = parent.frame()) 
[01:29:12.929]                   {
[01:29:12.929]                     if (is.function(workers)) 
[01:29:12.929]                       workers <- workers()
[01:29:12.929]                     workers <- structure(as.integer(workers), 
[01:29:12.929]                       class = class(workers))
[01:29:12.929]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:12.929]                       workers >= 1)
[01:29:12.929]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:12.929]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:12.929]                     }
[01:29:12.929]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:12.929]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:12.929]                       envir = envir)
[01:29:12.929]                     if (!future$lazy) 
[01:29:12.929]                       future <- run(future)
[01:29:12.929]                     invisible(future)
[01:29:12.929]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:12.929]                 }
[01:29:12.929]             }
[01:29:12.929]         }
[01:29:12.929]     })
[01:29:12.929]     if (TRUE) {
[01:29:12.929]         base::sink(type = "output", split = FALSE)
[01:29:12.929]         if (TRUE) {
[01:29:12.929]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:12.929]         }
[01:29:12.929]         else {
[01:29:12.929]             ...future.result["stdout"] <- base::list(NULL)
[01:29:12.929]         }
[01:29:12.929]         base::close(...future.stdout)
[01:29:12.929]         ...future.stdout <- NULL
[01:29:12.929]     }
[01:29:12.929]     ...future.result$conditions <- ...future.conditions
[01:29:12.929]     ...future.result$finished <- base::Sys.time()
[01:29:12.929]     ...future.result
[01:29:12.929] }
[01:29:12.934] Exporting 1 global objects (56 bytes) to cluster node #1 ...
[01:29:12.935] Exporting 'kk' (56 bytes) to cluster node #1 ...
[01:29:12.935] Exporting 'kk' (56 bytes) to cluster node #1 ... DONE
[01:29:12.935] Exporting 1 global objects (56 bytes) to cluster node #1 ... DONE
[01:29:12.936] MultisessionFuture started
[01:29:12.936] - Launch lazy future ... done
[01:29:12.936] run() for 'MultisessionFuture' ... done
[01:29:13.066] receiveMessageFromWorker() for ClusterFuture ...
[01:29:13.066] - Validating connection of MultisessionFuture
[01:29:13.067] - received message: FutureResult
[01:29:13.067] - Received FutureResult
[01:29:13.067] - Erased future from FutureRegistry
[01:29:13.067] result() for ClusterFuture ...
[01:29:13.068] - result already collected: FutureResult
[01:29:13.068] result() for ClusterFuture ... done
[01:29:13.068] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:13.068] Future #1
[01:29:13.068]  length: 2 (resolved future 1)
[01:29:13.068] run() for 'Future' ...
[01:29:13.069] - state: 'created'
[01:29:13.069] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:13.083] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:13.083] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:13.084]   - Field: 'node'
[01:29:13.084]   - Field: 'label'
[01:29:13.084]   - Field: 'local'
[01:29:13.084]   - Field: 'owner'
[01:29:13.084]   - Field: 'envir'
[01:29:13.084]   - Field: 'workers'
[01:29:13.085]   - Field: 'packages'
[01:29:13.085]   - Field: 'gc'
[01:29:13.085]   - Field: 'conditions'
[01:29:13.085]   - Field: 'persistent'
[01:29:13.085]   - Field: 'expr'
[01:29:13.086]   - Field: 'uuid'
[01:29:13.086]   - Field: 'seed'
[01:29:13.086]   - Field: 'version'
[01:29:13.086]   - Field: 'result'
[01:29:13.086]   - Field: 'asynchronous'
[01:29:13.086]   - Field: 'calls'
[01:29:13.087]   - Field: 'globals'
[01:29:13.087]   - Field: 'stdout'
[01:29:13.087]   - Field: 'earlySignal'
[01:29:13.087]   - Field: 'lazy'
[01:29:13.087]   - Field: 'state'
[01:29:13.087] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:13.088] - Launch lazy future ...
[01:29:13.088] Packages needed by the future expression (n = 0): <none>
[01:29:13.088] Packages needed by future strategies (n = 0): <none>
[01:29:13.089] {
[01:29:13.089]     {
[01:29:13.089]         {
[01:29:13.089]             ...future.startTime <- base::Sys.time()
[01:29:13.089]             {
[01:29:13.089]                 {
[01:29:13.089]                   {
[01:29:13.089]                     {
[01:29:13.089]                       base::local({
[01:29:13.089]                         has_future <- base::requireNamespace("future", 
[01:29:13.089]                           quietly = TRUE)
[01:29:13.089]                         if (has_future) {
[01:29:13.089]                           ns <- base::getNamespace("future")
[01:29:13.089]                           version <- ns[[".package"]][["version"]]
[01:29:13.089]                           if (is.null(version)) 
[01:29:13.089]                             version <- utils::packageVersion("future")
[01:29:13.089]                         }
[01:29:13.089]                         else {
[01:29:13.089]                           version <- NULL
[01:29:13.089]                         }
[01:29:13.089]                         if (!has_future || version < "1.8.0") {
[01:29:13.089]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:13.089]                             "", base::R.version$version.string), 
[01:29:13.089]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:13.089]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:13.089]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:13.089]                               "release", "version")], collapse = " "), 
[01:29:13.089]                             hostname = base::Sys.info()[["nodename"]])
[01:29:13.089]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:13.089]                             info)
[01:29:13.089]                           info <- base::paste(info, collapse = "; ")
[01:29:13.089]                           if (!has_future) {
[01:29:13.089]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:13.089]                               info)
[01:29:13.089]                           }
[01:29:13.089]                           else {
[01:29:13.089]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:13.089]                               info, version)
[01:29:13.089]                           }
[01:29:13.089]                           base::stop(msg)
[01:29:13.089]                         }
[01:29:13.089]                       })
[01:29:13.089]                     }
[01:29:13.089]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:13.089]                     base::options(mc.cores = 1L)
[01:29:13.089]                   }
[01:29:13.089]                   options(future.plan = NULL)
[01:29:13.089]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:13.089]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:13.089]                 }
[01:29:13.089]                 ...future.workdir <- getwd()
[01:29:13.089]             }
[01:29:13.089]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:13.089]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:13.089]         }
[01:29:13.089]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:13.089]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:13.089]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:13.089]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:13.089]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:13.089]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:13.089]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:13.089]             base::names(...future.oldOptions))
[01:29:13.089]     }
[01:29:13.089]     if (FALSE) {
[01:29:13.089]     }
[01:29:13.089]     else {
[01:29:13.089]         if (TRUE) {
[01:29:13.089]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:13.089]                 open = "w")
[01:29:13.089]         }
[01:29:13.089]         else {
[01:29:13.089]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:13.089]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:13.089]         }
[01:29:13.089]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:13.089]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:13.089]             base::sink(type = "output", split = FALSE)
[01:29:13.089]             base::close(...future.stdout)
[01:29:13.089]         }, add = TRUE)
[01:29:13.089]     }
[01:29:13.089]     ...future.frame <- base::sys.nframe()
[01:29:13.089]     ...future.conditions <- base::list()
[01:29:13.089]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:13.089]     if (FALSE) {
[01:29:13.089]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:13.089]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:13.089]     }
[01:29:13.089]     ...future.result <- base::tryCatch({
[01:29:13.089]         base::withCallingHandlers({
[01:29:13.089]             ...future.value <- base::withVisible(base::local({
[01:29:13.089]                 ...future.makeSendCondition <- base::local({
[01:29:13.089]                   sendCondition <- NULL
[01:29:13.089]                   function(frame = 1L) {
[01:29:13.089]                     if (is.function(sendCondition)) 
[01:29:13.089]                       return(sendCondition)
[01:29:13.089]                     ns <- getNamespace("parallel")
[01:29:13.089]                     if (exists("sendData", mode = "function", 
[01:29:13.089]                       envir = ns)) {
[01:29:13.089]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:13.089]                         envir = ns)
[01:29:13.089]                       envir <- sys.frame(frame)
[01:29:13.089]                       master <- NULL
[01:29:13.089]                       while (!identical(envir, .GlobalEnv) && 
[01:29:13.089]                         !identical(envir, emptyenv())) {
[01:29:13.089]                         if (exists("master", mode = "list", envir = envir, 
[01:29:13.089]                           inherits = FALSE)) {
[01:29:13.089]                           master <- get("master", mode = "list", 
[01:29:13.089]                             envir = envir, inherits = FALSE)
[01:29:13.089]                           if (inherits(master, c("SOCKnode", 
[01:29:13.089]                             "SOCK0node"))) {
[01:29:13.089]                             sendCondition <<- function(cond) {
[01:29:13.089]                               data <- list(type = "VALUE", value = cond, 
[01:29:13.089]                                 success = TRUE)
[01:29:13.089]                               parallel_sendData(master, data)
[01:29:13.089]                             }
[01:29:13.089]                             return(sendCondition)
[01:29:13.089]                           }
[01:29:13.089]                         }
[01:29:13.089]                         frame <- frame + 1L
[01:29:13.089]                         envir <- sys.frame(frame)
[01:29:13.089]                       }
[01:29:13.089]                     }
[01:29:13.089]                     sendCondition <<- function(cond) NULL
[01:29:13.089]                   }
[01:29:13.089]                 })
[01:29:13.089]                 withCallingHandlers({
[01:29:13.089]                   {
[01:29:13.089]                     Sys.sleep(0.1)
[01:29:13.089]                     kk
[01:29:13.089]                   }
[01:29:13.089]                 }, immediateCondition = function(cond) {
[01:29:13.089]                   sendCondition <- ...future.makeSendCondition()
[01:29:13.089]                   sendCondition(cond)
[01:29:13.089]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.089]                   {
[01:29:13.089]                     inherits <- base::inherits
[01:29:13.089]                     invokeRestart <- base::invokeRestart
[01:29:13.089]                     is.null <- base::is.null
[01:29:13.089]                     muffled <- FALSE
[01:29:13.089]                     if (inherits(cond, "message")) {
[01:29:13.089]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:13.089]                       if (muffled) 
[01:29:13.089]                         invokeRestart("muffleMessage")
[01:29:13.089]                     }
[01:29:13.089]                     else if (inherits(cond, "warning")) {
[01:29:13.089]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:13.089]                       if (muffled) 
[01:29:13.089]                         invokeRestart("muffleWarning")
[01:29:13.089]                     }
[01:29:13.089]                     else if (inherits(cond, "condition")) {
[01:29:13.089]                       if (!is.null(pattern)) {
[01:29:13.089]                         computeRestarts <- base::computeRestarts
[01:29:13.089]                         grepl <- base::grepl
[01:29:13.089]                         restarts <- computeRestarts(cond)
[01:29:13.089]                         for (restart in restarts) {
[01:29:13.089]                           name <- restart$name
[01:29:13.089]                           if (is.null(name)) 
[01:29:13.089]                             next
[01:29:13.089]                           if (!grepl(pattern, name)) 
[01:29:13.089]                             next
[01:29:13.089]                           invokeRestart(restart)
[01:29:13.089]                           muffled <- TRUE
[01:29:13.089]                           break
[01:29:13.089]                         }
[01:29:13.089]                       }
[01:29:13.089]                     }
[01:29:13.089]                     invisible(muffled)
[01:29:13.089]                   }
[01:29:13.089]                   muffleCondition(cond)
[01:29:13.089]                 })
[01:29:13.089]             }))
[01:29:13.089]             future::FutureResult(value = ...future.value$value, 
[01:29:13.089]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:13.089]                   ...future.rng), globalenv = if (FALSE) 
[01:29:13.089]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:13.089]                     ...future.globalenv.names))
[01:29:13.089]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:13.089]         }, condition = base::local({
[01:29:13.089]             c <- base::c
[01:29:13.089]             inherits <- base::inherits
[01:29:13.089]             invokeRestart <- base::invokeRestart
[01:29:13.089]             length <- base::length
[01:29:13.089]             list <- base::list
[01:29:13.089]             seq.int <- base::seq.int
[01:29:13.089]             signalCondition <- base::signalCondition
[01:29:13.089]             sys.calls <- base::sys.calls
[01:29:13.089]             `[[` <- base::`[[`
[01:29:13.089]             `+` <- base::`+`
[01:29:13.089]             `<<-` <- base::`<<-`
[01:29:13.089]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:13.089]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:13.089]                   3L)]
[01:29:13.089]             }
[01:29:13.089]             function(cond) {
[01:29:13.089]                 is_error <- inherits(cond, "error")
[01:29:13.089]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:13.089]                   NULL)
[01:29:13.089]                 if (is_error) {
[01:29:13.089]                   sessionInformation <- function() {
[01:29:13.089]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:13.089]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:13.089]                       search = base::search(), system = base::Sys.info())
[01:29:13.089]                   }
[01:29:13.089]                   ...future.conditions[[length(...future.conditions) + 
[01:29:13.089]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:13.089]                     cond$call), session = sessionInformation(), 
[01:29:13.089]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:13.089]                   signalCondition(cond)
[01:29:13.089]                 }
[01:29:13.089]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:13.089]                 "immediateCondition"))) {
[01:29:13.089]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:13.089]                   ...future.conditions[[length(...future.conditions) + 
[01:29:13.089]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:13.089]                   if (TRUE && !signal) {
[01:29:13.089]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.089]                     {
[01:29:13.089]                       inherits <- base::inherits
[01:29:13.089]                       invokeRestart <- base::invokeRestart
[01:29:13.089]                       is.null <- base::is.null
[01:29:13.089]                       muffled <- FALSE
[01:29:13.089]                       if (inherits(cond, "message")) {
[01:29:13.089]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:13.089]                         if (muffled) 
[01:29:13.089]                           invokeRestart("muffleMessage")
[01:29:13.089]                       }
[01:29:13.089]                       else if (inherits(cond, "warning")) {
[01:29:13.089]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:13.089]                         if (muffled) 
[01:29:13.089]                           invokeRestart("muffleWarning")
[01:29:13.089]                       }
[01:29:13.089]                       else if (inherits(cond, "condition")) {
[01:29:13.089]                         if (!is.null(pattern)) {
[01:29:13.089]                           computeRestarts <- base::computeRestarts
[01:29:13.089]                           grepl <- base::grepl
[01:29:13.089]                           restarts <- computeRestarts(cond)
[01:29:13.089]                           for (restart in restarts) {
[01:29:13.089]                             name <- restart$name
[01:29:13.089]                             if (is.null(name)) 
[01:29:13.089]                               next
[01:29:13.089]                             if (!grepl(pattern, name)) 
[01:29:13.089]                               next
[01:29:13.089]                             invokeRestart(restart)
[01:29:13.089]                             muffled <- TRUE
[01:29:13.089]                             break
[01:29:13.089]                           }
[01:29:13.089]                         }
[01:29:13.089]                       }
[01:29:13.089]                       invisible(muffled)
[01:29:13.089]                     }
[01:29:13.089]                     muffleCondition(cond, pattern = "^muffle")
[01:29:13.089]                   }
[01:29:13.089]                 }
[01:29:13.089]                 else {
[01:29:13.089]                   if (TRUE) {
[01:29:13.089]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.089]                     {
[01:29:13.089]                       inherits <- base::inherits
[01:29:13.089]                       invokeRestart <- base::invokeRestart
[01:29:13.089]                       is.null <- base::is.null
[01:29:13.089]                       muffled <- FALSE
[01:29:13.089]                       if (inherits(cond, "message")) {
[01:29:13.089]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:13.089]                         if (muffled) 
[01:29:13.089]                           invokeRestart("muffleMessage")
[01:29:13.089]                       }
[01:29:13.089]                       else if (inherits(cond, "warning")) {
[01:29:13.089]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:13.089]                         if (muffled) 
[01:29:13.089]                           invokeRestart("muffleWarning")
[01:29:13.089]                       }
[01:29:13.089]                       else if (inherits(cond, "condition")) {
[01:29:13.089]                         if (!is.null(pattern)) {
[01:29:13.089]                           computeRestarts <- base::computeRestarts
[01:29:13.089]                           grepl <- base::grepl
[01:29:13.089]                           restarts <- computeRestarts(cond)
[01:29:13.089]                           for (restart in restarts) {
[01:29:13.089]                             name <- restart$name
[01:29:13.089]                             if (is.null(name)) 
[01:29:13.089]                               next
[01:29:13.089]                             if (!grepl(pattern, name)) 
[01:29:13.089]                               next
[01:29:13.089]                             invokeRestart(restart)
[01:29:13.089]                             muffled <- TRUE
[01:29:13.089]                             break
[01:29:13.089]                           }
[01:29:13.089]                         }
[01:29:13.089]                       }
[01:29:13.089]                       invisible(muffled)
[01:29:13.089]                     }
[01:29:13.089]                     muffleCondition(cond, pattern = "^muffle")
[01:29:13.089]                   }
[01:29:13.089]                 }
[01:29:13.089]             }
[01:29:13.089]         }))
[01:29:13.089]     }, error = function(ex) {
[01:29:13.089]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:13.089]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:13.089]                 ...future.rng), started = ...future.startTime, 
[01:29:13.089]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:13.089]             version = "1.8"), class = "FutureResult")
[01:29:13.089]     }, finally = {
[01:29:13.089]         if (!identical(...future.workdir, getwd())) 
[01:29:13.089]             setwd(...future.workdir)
[01:29:13.089]         {
[01:29:13.089]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:13.089]                 ...future.oldOptions$nwarnings <- NULL
[01:29:13.089]             }
[01:29:13.089]             base::options(...future.oldOptions)
[01:29:13.089]             if (.Platform$OS.type == "windows") {
[01:29:13.089]                 old_names <- names(...future.oldEnvVars)
[01:29:13.089]                 envs <- base::Sys.getenv()
[01:29:13.089]                 names <- names(envs)
[01:29:13.089]                 common <- intersect(names, old_names)
[01:29:13.089]                 added <- setdiff(names, old_names)
[01:29:13.089]                 removed <- setdiff(old_names, names)
[01:29:13.089]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:13.089]                   envs[common]]
[01:29:13.089]                 NAMES <- toupper(changed)
[01:29:13.089]                 args <- list()
[01:29:13.089]                 for (kk in seq_along(NAMES)) {
[01:29:13.089]                   name <- changed[[kk]]
[01:29:13.089]                   NAME <- NAMES[[kk]]
[01:29:13.089]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.089]                     next
[01:29:13.089]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:13.089]                 }
[01:29:13.089]                 NAMES <- toupper(added)
[01:29:13.089]                 for (kk in seq_along(NAMES)) {
[01:29:13.089]                   name <- added[[kk]]
[01:29:13.089]                   NAME <- NAMES[[kk]]
[01:29:13.089]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.089]                     next
[01:29:13.089]                   args[[name]] <- ""
[01:29:13.089]                 }
[01:29:13.089]                 NAMES <- toupper(removed)
[01:29:13.089]                 for (kk in seq_along(NAMES)) {
[01:29:13.089]                   name <- removed[[kk]]
[01:29:13.089]                   NAME <- NAMES[[kk]]
[01:29:13.089]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.089]                     next
[01:29:13.089]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:13.089]                 }
[01:29:13.089]                 if (length(args) > 0) 
[01:29:13.089]                   base::do.call(base::Sys.setenv, args = args)
[01:29:13.089]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:13.089]             }
[01:29:13.089]             else {
[01:29:13.089]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:13.089]             }
[01:29:13.089]             {
[01:29:13.089]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:13.089]                   0L) {
[01:29:13.089]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:13.089]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:13.089]                   base::options(opts)
[01:29:13.089]                 }
[01:29:13.089]                 {
[01:29:13.089]                   {
[01:29:13.089]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:13.089]                     NULL
[01:29:13.089]                   }
[01:29:13.089]                   options(future.plan = NULL)
[01:29:13.089]                   if (is.na(NA_character_)) 
[01:29:13.089]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:13.089]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:13.089]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:13.089]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:13.089]                     envir = parent.frame()) 
[01:29:13.089]                   {
[01:29:13.089]                     if (is.function(workers)) 
[01:29:13.089]                       workers <- workers()
[01:29:13.089]                     workers <- structure(as.integer(workers), 
[01:29:13.089]                       class = class(workers))
[01:29:13.089]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:13.089]                       workers >= 1)
[01:29:13.089]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:13.089]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:13.089]                     }
[01:29:13.089]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:13.089]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:13.089]                       envir = envir)
[01:29:13.089]                     if (!future$lazy) 
[01:29:13.089]                       future <- run(future)
[01:29:13.089]                     invisible(future)
[01:29:13.089]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:13.089]                 }
[01:29:13.089]             }
[01:29:13.089]         }
[01:29:13.089]     })
[01:29:13.089]     if (TRUE) {
[01:29:13.089]         base::sink(type = "output", split = FALSE)
[01:29:13.089]         if (TRUE) {
[01:29:13.089]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:13.089]         }
[01:29:13.089]         else {
[01:29:13.089]             ...future.result["stdout"] <- base::list(NULL)
[01:29:13.089]         }
[01:29:13.089]         base::close(...future.stdout)
[01:29:13.089]         ...future.stdout <- NULL
[01:29:13.089]     }
[01:29:13.089]     ...future.result$conditions <- ...future.conditions
[01:29:13.089]     ...future.result$finished <- base::Sys.time()
[01:29:13.089]     ...future.result
[01:29:13.089] }
[01:29:13.095] Exporting 1 global objects (56 bytes) to cluster node #1 ...
[01:29:13.095] Exporting 'kk' (56 bytes) to cluster node #1 ...
[01:29:13.095] Exporting 'kk' (56 bytes) to cluster node #1 ... DONE
[01:29:13.096] Exporting 1 global objects (56 bytes) to cluster node #1 ... DONE
[01:29:13.096] MultisessionFuture started
[01:29:13.096] - Launch lazy future ... done
[01:29:13.097] run() for 'MultisessionFuture' ... done
[01:29:13.224] receiveMessageFromWorker() for ClusterFuture ...
[01:29:13.224] - Validating connection of MultisessionFuture
[01:29:13.225] - received message: FutureResult
[01:29:13.225] - Received FutureResult
[01:29:13.225] - Erased future from FutureRegistry
[01:29:13.225] result() for ClusterFuture ...
[01:29:13.225] - result already collected: FutureResult
[01:29:13.226] result() for ClusterFuture ... done
[01:29:13.226] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:13.226] Future #2
[01:29:13.226]  length: 1 (resolved future 2)
[01:29:13.226] run() for 'Future' ...
[01:29:13.227] - state: 'created'
[01:29:13.227] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:13.243] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:13.244] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:13.244]   - Field: 'node'
[01:29:13.244]   - Field: 'label'
[01:29:13.244]   - Field: 'local'
[01:29:13.245]   - Field: 'owner'
[01:29:13.245]   - Field: 'envir'
[01:29:13.245]   - Field: 'workers'
[01:29:13.245]   - Field: 'packages'
[01:29:13.245]   - Field: 'gc'
[01:29:13.245]   - Field: 'conditions'
[01:29:13.246]   - Field: 'persistent'
[01:29:13.246]   - Field: 'expr'
[01:29:13.246]   - Field: 'uuid'
[01:29:13.246]   - Field: 'seed'
[01:29:13.246]   - Field: 'version'
[01:29:13.247]   - Field: 'result'
[01:29:13.247]   - Field: 'asynchronous'
[01:29:13.247]   - Field: 'calls'
[01:29:13.247]   - Field: 'globals'
[01:29:13.247]   - Field: 'stdout'
[01:29:13.247]   - Field: 'earlySignal'
[01:29:13.248]   - Field: 'lazy'
[01:29:13.248]   - Field: 'state'
[01:29:13.248] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:13.248] - Launch lazy future ...
[01:29:13.249] Packages needed by the future expression (n = 0): <none>
[01:29:13.249] Packages needed by future strategies (n = 0): <none>
[01:29:13.249] {
[01:29:13.249]     {
[01:29:13.249]         {
[01:29:13.249]             ...future.startTime <- base::Sys.time()
[01:29:13.249]             {
[01:29:13.249]                 {
[01:29:13.249]                   {
[01:29:13.249]                     {
[01:29:13.249]                       base::local({
[01:29:13.249]                         has_future <- base::requireNamespace("future", 
[01:29:13.249]                           quietly = TRUE)
[01:29:13.249]                         if (has_future) {
[01:29:13.249]                           ns <- base::getNamespace("future")
[01:29:13.249]                           version <- ns[[".package"]][["version"]]
[01:29:13.249]                           if (is.null(version)) 
[01:29:13.249]                             version <- utils::packageVersion("future")
[01:29:13.249]                         }
[01:29:13.249]                         else {
[01:29:13.249]                           version <- NULL
[01:29:13.249]                         }
[01:29:13.249]                         if (!has_future || version < "1.8.0") {
[01:29:13.249]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:13.249]                             "", base::R.version$version.string), 
[01:29:13.249]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:13.249]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:13.249]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:13.249]                               "release", "version")], collapse = " "), 
[01:29:13.249]                             hostname = base::Sys.info()[["nodename"]])
[01:29:13.249]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:13.249]                             info)
[01:29:13.249]                           info <- base::paste(info, collapse = "; ")
[01:29:13.249]                           if (!has_future) {
[01:29:13.249]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:13.249]                               info)
[01:29:13.249]                           }
[01:29:13.249]                           else {
[01:29:13.249]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:13.249]                               info, version)
[01:29:13.249]                           }
[01:29:13.249]                           base::stop(msg)
[01:29:13.249]                         }
[01:29:13.249]                       })
[01:29:13.249]                     }
[01:29:13.249]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:13.249]                     base::options(mc.cores = 1L)
[01:29:13.249]                   }
[01:29:13.249]                   options(future.plan = NULL)
[01:29:13.249]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:13.249]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:13.249]                 }
[01:29:13.249]                 ...future.workdir <- getwd()
[01:29:13.249]             }
[01:29:13.249]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:13.249]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:13.249]         }
[01:29:13.249]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:13.249]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:13.249]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:13.249]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:13.249]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:13.249]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:13.249]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:13.249]             base::names(...future.oldOptions))
[01:29:13.249]     }
[01:29:13.249]     if (FALSE) {
[01:29:13.249]     }
[01:29:13.249]     else {
[01:29:13.249]         if (TRUE) {
[01:29:13.249]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:13.249]                 open = "w")
[01:29:13.249]         }
[01:29:13.249]         else {
[01:29:13.249]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:13.249]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:13.249]         }
[01:29:13.249]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:13.249]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:13.249]             base::sink(type = "output", split = FALSE)
[01:29:13.249]             base::close(...future.stdout)
[01:29:13.249]         }, add = TRUE)
[01:29:13.249]     }
[01:29:13.249]     ...future.frame <- base::sys.nframe()
[01:29:13.249]     ...future.conditions <- base::list()
[01:29:13.249]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:13.249]     if (FALSE) {
[01:29:13.249]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:13.249]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:13.249]     }
[01:29:13.249]     ...future.result <- base::tryCatch({
[01:29:13.249]         base::withCallingHandlers({
[01:29:13.249]             ...future.value <- base::withVisible(base::local({
[01:29:13.249]                 ...future.makeSendCondition <- base::local({
[01:29:13.249]                   sendCondition <- NULL
[01:29:13.249]                   function(frame = 1L) {
[01:29:13.249]                     if (is.function(sendCondition)) 
[01:29:13.249]                       return(sendCondition)
[01:29:13.249]                     ns <- getNamespace("parallel")
[01:29:13.249]                     if (exists("sendData", mode = "function", 
[01:29:13.249]                       envir = ns)) {
[01:29:13.249]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:13.249]                         envir = ns)
[01:29:13.249]                       envir <- sys.frame(frame)
[01:29:13.249]                       master <- NULL
[01:29:13.249]                       while (!identical(envir, .GlobalEnv) && 
[01:29:13.249]                         !identical(envir, emptyenv())) {
[01:29:13.249]                         if (exists("master", mode = "list", envir = envir, 
[01:29:13.249]                           inherits = FALSE)) {
[01:29:13.249]                           master <- get("master", mode = "list", 
[01:29:13.249]                             envir = envir, inherits = FALSE)
[01:29:13.249]                           if (inherits(master, c("SOCKnode", 
[01:29:13.249]                             "SOCK0node"))) {
[01:29:13.249]                             sendCondition <<- function(cond) {
[01:29:13.249]                               data <- list(type = "VALUE", value = cond, 
[01:29:13.249]                                 success = TRUE)
[01:29:13.249]                               parallel_sendData(master, data)
[01:29:13.249]                             }
[01:29:13.249]                             return(sendCondition)
[01:29:13.249]                           }
[01:29:13.249]                         }
[01:29:13.249]                         frame <- frame + 1L
[01:29:13.249]                         envir <- sys.frame(frame)
[01:29:13.249]                       }
[01:29:13.249]                     }
[01:29:13.249]                     sendCondition <<- function(cond) NULL
[01:29:13.249]                   }
[01:29:13.249]                 })
[01:29:13.249]                 withCallingHandlers({
[01:29:13.249]                   {
[01:29:13.249]                     Sys.sleep(0.1)
[01:29:13.249]                     kk
[01:29:13.249]                   }
[01:29:13.249]                 }, immediateCondition = function(cond) {
[01:29:13.249]                   sendCondition <- ...future.makeSendCondition()
[01:29:13.249]                   sendCondition(cond)
[01:29:13.249]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.249]                   {
[01:29:13.249]                     inherits <- base::inherits
[01:29:13.249]                     invokeRestart <- base::invokeRestart
[01:29:13.249]                     is.null <- base::is.null
[01:29:13.249]                     muffled <- FALSE
[01:29:13.249]                     if (inherits(cond, "message")) {
[01:29:13.249]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:13.249]                       if (muffled) 
[01:29:13.249]                         invokeRestart("muffleMessage")
[01:29:13.249]                     }
[01:29:13.249]                     else if (inherits(cond, "warning")) {
[01:29:13.249]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:13.249]                       if (muffled) 
[01:29:13.249]                         invokeRestart("muffleWarning")
[01:29:13.249]                     }
[01:29:13.249]                     else if (inherits(cond, "condition")) {
[01:29:13.249]                       if (!is.null(pattern)) {
[01:29:13.249]                         computeRestarts <- base::computeRestarts
[01:29:13.249]                         grepl <- base::grepl
[01:29:13.249]                         restarts <- computeRestarts(cond)
[01:29:13.249]                         for (restart in restarts) {
[01:29:13.249]                           name <- restart$name
[01:29:13.249]                           if (is.null(name)) 
[01:29:13.249]                             next
[01:29:13.249]                           if (!grepl(pattern, name)) 
[01:29:13.249]                             next
[01:29:13.249]                           invokeRestart(restart)
[01:29:13.249]                           muffled <- TRUE
[01:29:13.249]                           break
[01:29:13.249]                         }
[01:29:13.249]                       }
[01:29:13.249]                     }
[01:29:13.249]                     invisible(muffled)
[01:29:13.249]                   }
[01:29:13.249]                   muffleCondition(cond)
[01:29:13.249]                 })
[01:29:13.249]             }))
[01:29:13.249]             future::FutureResult(value = ...future.value$value, 
[01:29:13.249]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:13.249]                   ...future.rng), globalenv = if (FALSE) 
[01:29:13.249]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:13.249]                     ...future.globalenv.names))
[01:29:13.249]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:13.249]         }, condition = base::local({
[01:29:13.249]             c <- base::c
[01:29:13.249]             inherits <- base::inherits
[01:29:13.249]             invokeRestart <- base::invokeRestart
[01:29:13.249]             length <- base::length
[01:29:13.249]             list <- base::list
[01:29:13.249]             seq.int <- base::seq.int
[01:29:13.249]             signalCondition <- base::signalCondition
[01:29:13.249]             sys.calls <- base::sys.calls
[01:29:13.249]             `[[` <- base::`[[`
[01:29:13.249]             `+` <- base::`+`
[01:29:13.249]             `<<-` <- base::`<<-`
[01:29:13.249]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:13.249]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:13.249]                   3L)]
[01:29:13.249]             }
[01:29:13.249]             function(cond) {
[01:29:13.249]                 is_error <- inherits(cond, "error")
[01:29:13.249]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:13.249]                   NULL)
[01:29:13.249]                 if (is_error) {
[01:29:13.249]                   sessionInformation <- function() {
[01:29:13.249]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:13.249]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:13.249]                       search = base::search(), system = base::Sys.info())
[01:29:13.249]                   }
[01:29:13.249]                   ...future.conditions[[length(...future.conditions) + 
[01:29:13.249]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:13.249]                     cond$call), session = sessionInformation(), 
[01:29:13.249]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:13.249]                   signalCondition(cond)
[01:29:13.249]                 }
[01:29:13.249]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:13.249]                 "immediateCondition"))) {
[01:29:13.249]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:13.249]                   ...future.conditions[[length(...future.conditions) + 
[01:29:13.249]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:13.249]                   if (TRUE && !signal) {
[01:29:13.249]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.249]                     {
[01:29:13.249]                       inherits <- base::inherits
[01:29:13.249]                       invokeRestart <- base::invokeRestart
[01:29:13.249]                       is.null <- base::is.null
[01:29:13.249]                       muffled <- FALSE
[01:29:13.249]                       if (inherits(cond, "message")) {
[01:29:13.249]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:13.249]                         if (muffled) 
[01:29:13.249]                           invokeRestart("muffleMessage")
[01:29:13.249]                       }
[01:29:13.249]                       else if (inherits(cond, "warning")) {
[01:29:13.249]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:13.249]                         if (muffled) 
[01:29:13.249]                           invokeRestart("muffleWarning")
[01:29:13.249]                       }
[01:29:13.249]                       else if (inherits(cond, "condition")) {
[01:29:13.249]                         if (!is.null(pattern)) {
[01:29:13.249]                           computeRestarts <- base::computeRestarts
[01:29:13.249]                           grepl <- base::grepl
[01:29:13.249]                           restarts <- computeRestarts(cond)
[01:29:13.249]                           for (restart in restarts) {
[01:29:13.249]                             name <- restart$name
[01:29:13.249]                             if (is.null(name)) 
[01:29:13.249]                               next
[01:29:13.249]                             if (!grepl(pattern, name)) 
[01:29:13.249]                               next
[01:29:13.249]                             invokeRestart(restart)
[01:29:13.249]                             muffled <- TRUE
[01:29:13.249]                             break
[01:29:13.249]                           }
[01:29:13.249]                         }
[01:29:13.249]                       }
[01:29:13.249]                       invisible(muffled)
[01:29:13.249]                     }
[01:29:13.249]                     muffleCondition(cond, pattern = "^muffle")
[01:29:13.249]                   }
[01:29:13.249]                 }
[01:29:13.249]                 else {
[01:29:13.249]                   if (TRUE) {
[01:29:13.249]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.249]                     {
[01:29:13.249]                       inherits <- base::inherits
[01:29:13.249]                       invokeRestart <- base::invokeRestart
[01:29:13.249]                       is.null <- base::is.null
[01:29:13.249]                       muffled <- FALSE
[01:29:13.249]                       if (inherits(cond, "message")) {
[01:29:13.249]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:13.249]                         if (muffled) 
[01:29:13.249]                           invokeRestart("muffleMessage")
[01:29:13.249]                       }
[01:29:13.249]                       else if (inherits(cond, "warning")) {
[01:29:13.249]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:13.249]                         if (muffled) 
[01:29:13.249]                           invokeRestart("muffleWarning")
[01:29:13.249]                       }
[01:29:13.249]                       else if (inherits(cond, "condition")) {
[01:29:13.249]                         if (!is.null(pattern)) {
[01:29:13.249]                           computeRestarts <- base::computeRestarts
[01:29:13.249]                           grepl <- base::grepl
[01:29:13.249]                           restarts <- computeRestarts(cond)
[01:29:13.249]                           for (restart in restarts) {
[01:29:13.249]                             name <- restart$name
[01:29:13.249]                             if (is.null(name)) 
[01:29:13.249]                               next
[01:29:13.249]                             if (!grepl(pattern, name)) 
[01:29:13.249]                               next
[01:29:13.249]                             invokeRestart(restart)
[01:29:13.249]                             muffled <- TRUE
[01:29:13.249]                             break
[01:29:13.249]                           }
[01:29:13.249]                         }
[01:29:13.249]                       }
[01:29:13.249]                       invisible(muffled)
[01:29:13.249]                     }
[01:29:13.249]                     muffleCondition(cond, pattern = "^muffle")
[01:29:13.249]                   }
[01:29:13.249]                 }
[01:29:13.249]             }
[01:29:13.249]         }))
[01:29:13.249]     }, error = function(ex) {
[01:29:13.249]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:13.249]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:13.249]                 ...future.rng), started = ...future.startTime, 
[01:29:13.249]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:13.249]             version = "1.8"), class = "FutureResult")
[01:29:13.249]     }, finally = {
[01:29:13.249]         if (!identical(...future.workdir, getwd())) 
[01:29:13.249]             setwd(...future.workdir)
[01:29:13.249]         {
[01:29:13.249]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:13.249]                 ...future.oldOptions$nwarnings <- NULL
[01:29:13.249]             }
[01:29:13.249]             base::options(...future.oldOptions)
[01:29:13.249]             if (.Platform$OS.type == "windows") {
[01:29:13.249]                 old_names <- names(...future.oldEnvVars)
[01:29:13.249]                 envs <- base::Sys.getenv()
[01:29:13.249]                 names <- names(envs)
[01:29:13.249]                 common <- intersect(names, old_names)
[01:29:13.249]                 added <- setdiff(names, old_names)
[01:29:13.249]                 removed <- setdiff(old_names, names)
[01:29:13.249]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:13.249]                   envs[common]]
[01:29:13.249]                 NAMES <- toupper(changed)
[01:29:13.249]                 args <- list()
[01:29:13.249]                 for (kk in seq_along(NAMES)) {
[01:29:13.249]                   name <- changed[[kk]]
[01:29:13.249]                   NAME <- NAMES[[kk]]
[01:29:13.249]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.249]                     next
[01:29:13.249]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:13.249]                 }
[01:29:13.249]                 NAMES <- toupper(added)
[01:29:13.249]                 for (kk in seq_along(NAMES)) {
[01:29:13.249]                   name <- added[[kk]]
[01:29:13.249]                   NAME <- NAMES[[kk]]
[01:29:13.249]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.249]                     next
[01:29:13.249]                   args[[name]] <- ""
[01:29:13.249]                 }
[01:29:13.249]                 NAMES <- toupper(removed)
[01:29:13.249]                 for (kk in seq_along(NAMES)) {
[01:29:13.249]                   name <- removed[[kk]]
[01:29:13.249]                   NAME <- NAMES[[kk]]
[01:29:13.249]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.249]                     next
[01:29:13.249]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:13.249]                 }
[01:29:13.249]                 if (length(args) > 0) 
[01:29:13.249]                   base::do.call(base::Sys.setenv, args = args)
[01:29:13.249]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:13.249]             }
[01:29:13.249]             else {
[01:29:13.249]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:13.249]             }
[01:29:13.249]             {
[01:29:13.249]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:13.249]                   0L) {
[01:29:13.249]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:13.249]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:13.249]                   base::options(opts)
[01:29:13.249]                 }
[01:29:13.249]                 {
[01:29:13.249]                   {
[01:29:13.249]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:13.249]                     NULL
[01:29:13.249]                   }
[01:29:13.249]                   options(future.plan = NULL)
[01:29:13.249]                   if (is.na(NA_character_)) 
[01:29:13.249]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:13.249]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:13.249]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:13.249]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:13.249]                     envir = parent.frame()) 
[01:29:13.249]                   {
[01:29:13.249]                     if (is.function(workers)) 
[01:29:13.249]                       workers <- workers()
[01:29:13.249]                     workers <- structure(as.integer(workers), 
[01:29:13.249]                       class = class(workers))
[01:29:13.249]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:13.249]                       workers >= 1)
[01:29:13.249]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:13.249]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:13.249]                     }
[01:29:13.249]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:13.249]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:13.249]                       envir = envir)
[01:29:13.249]                     if (!future$lazy) 
[01:29:13.249]                       future <- run(future)
[01:29:13.249]                     invisible(future)
[01:29:13.249]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:13.249]                 }
[01:29:13.249]             }
[01:29:13.249]         }
[01:29:13.249]     })
[01:29:13.249]     if (TRUE) {
[01:29:13.249]         base::sink(type = "output", split = FALSE)
[01:29:13.249]         if (TRUE) {
[01:29:13.249]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:13.249]         }
[01:29:13.249]         else {
[01:29:13.249]             ...future.result["stdout"] <- base::list(NULL)
[01:29:13.249]         }
[01:29:13.249]         base::close(...future.stdout)
[01:29:13.249]         ...future.stdout <- NULL
[01:29:13.249]     }
[01:29:13.249]     ...future.result$conditions <- ...future.conditions
[01:29:13.249]     ...future.result$finished <- base::Sys.time()
[01:29:13.249]     ...future.result
[01:29:13.249] }
[01:29:13.255] Exporting 1 global objects (56 bytes) to cluster node #1 ...
[01:29:13.255] Exporting 'kk' (56 bytes) to cluster node #1 ...
[01:29:13.256] Exporting 'kk' (56 bytes) to cluster node #1 ... DONE
[01:29:13.256] Exporting 1 global objects (56 bytes) to cluster node #1 ... DONE
[01:29:13.256] MultisessionFuture started
[01:29:13.257] - Launch lazy future ... done
[01:29:13.257] run() for 'MultisessionFuture' ... done
[01:29:13.386] receiveMessageFromWorker() for ClusterFuture ...
[01:29:13.387] - Validating connection of MultisessionFuture
[01:29:13.387] - received message: FutureResult
[01:29:13.387] - Received FutureResult
[01:29:13.387] - Erased future from FutureRegistry
[01:29:13.388] result() for ClusterFuture ...
[01:29:13.388] - result already collected: FutureResult
[01:29:13.388] result() for ClusterFuture ... done
[01:29:13.388] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:13.388] Future #3
[01:29:13.388]  length: 0 (resolved future 3)
[01:29:13.389] resolve() on list ... DONE
*** resolve() for lists ... DONE
*** resolve() for environments ...
[01:29:13.390] resolve() on environment ...
[01:29:13.390]  recursive: 0
[01:29:13.390]  elements: [2] 'a', 'b'
[01:29:13.391]  length: 1 (resolved future 1)
[01:29:13.391]  length: 0 (resolved future 2)
[01:29:13.391] resolve() on environment ... DONE
[01:29:13.392] getGlobalsAndPackages() ...
[01:29:13.392] Searching for globals...
[01:29:13.392] 
[01:29:13.392] Searching for globals ... DONE
[01:29:13.393] - globals: [0] <none>
[01:29:13.393] getGlobalsAndPackages() ... DONE
[01:29:13.393] run() for 'Future' ...
[01:29:13.393] - state: 'created'
[01:29:13.393] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:13.408] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:13.408] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:13.409]   - Field: 'node'
[01:29:13.409]   - Field: 'label'
[01:29:13.409]   - Field: 'local'
[01:29:13.409]   - Field: 'owner'
[01:29:13.409]   - Field: 'envir'
[01:29:13.409]   - Field: 'workers'
[01:29:13.410]   - Field: 'packages'
[01:29:13.410]   - Field: 'gc'
[01:29:13.410]   - Field: 'conditions'
[01:29:13.410]   - Field: 'persistent'
[01:29:13.410]   - Field: 'expr'
[01:29:13.411]   - Field: 'uuid'
[01:29:13.411]   - Field: 'seed'
[01:29:13.411]   - Field: 'version'
[01:29:13.411]   - Field: 'result'
[01:29:13.411]   - Field: 'asynchronous'
[01:29:13.411]   - Field: 'calls'
[01:29:13.412]   - Field: 'globals'
[01:29:13.412]   - Field: 'stdout'
[01:29:13.412]   - Field: 'earlySignal'
[01:29:13.412]   - Field: 'lazy'
[01:29:13.412]   - Field: 'state'
[01:29:13.412] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:13.413] - Launch lazy future ...
[01:29:13.413] Packages needed by the future expression (n = 0): <none>
[01:29:13.413] Packages needed by future strategies (n = 0): <none>
[01:29:13.414] {
[01:29:13.414]     {
[01:29:13.414]         {
[01:29:13.414]             ...future.startTime <- base::Sys.time()
[01:29:13.414]             {
[01:29:13.414]                 {
[01:29:13.414]                   {
[01:29:13.414]                     {
[01:29:13.414]                       base::local({
[01:29:13.414]                         has_future <- base::requireNamespace("future", 
[01:29:13.414]                           quietly = TRUE)
[01:29:13.414]                         if (has_future) {
[01:29:13.414]                           ns <- base::getNamespace("future")
[01:29:13.414]                           version <- ns[[".package"]][["version"]]
[01:29:13.414]                           if (is.null(version)) 
[01:29:13.414]                             version <- utils::packageVersion("future")
[01:29:13.414]                         }
[01:29:13.414]                         else {
[01:29:13.414]                           version <- NULL
[01:29:13.414]                         }
[01:29:13.414]                         if (!has_future || version < "1.8.0") {
[01:29:13.414]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:13.414]                             "", base::R.version$version.string), 
[01:29:13.414]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:13.414]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:13.414]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:13.414]                               "release", "version")], collapse = " "), 
[01:29:13.414]                             hostname = base::Sys.info()[["nodename"]])
[01:29:13.414]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:13.414]                             info)
[01:29:13.414]                           info <- base::paste(info, collapse = "; ")
[01:29:13.414]                           if (!has_future) {
[01:29:13.414]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:13.414]                               info)
[01:29:13.414]                           }
[01:29:13.414]                           else {
[01:29:13.414]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:13.414]                               info, version)
[01:29:13.414]                           }
[01:29:13.414]                           base::stop(msg)
[01:29:13.414]                         }
[01:29:13.414]                       })
[01:29:13.414]                     }
[01:29:13.414]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:13.414]                     base::options(mc.cores = 1L)
[01:29:13.414]                   }
[01:29:13.414]                   options(future.plan = NULL)
[01:29:13.414]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:13.414]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:13.414]                 }
[01:29:13.414]                 ...future.workdir <- getwd()
[01:29:13.414]             }
[01:29:13.414]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:13.414]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:13.414]         }
[01:29:13.414]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:13.414]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:13.414]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:13.414]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:13.414]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:13.414]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:13.414]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:13.414]             base::names(...future.oldOptions))
[01:29:13.414]     }
[01:29:13.414]     if (FALSE) {
[01:29:13.414]     }
[01:29:13.414]     else {
[01:29:13.414]         if (TRUE) {
[01:29:13.414]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:13.414]                 open = "w")
[01:29:13.414]         }
[01:29:13.414]         else {
[01:29:13.414]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:13.414]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:13.414]         }
[01:29:13.414]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:13.414]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:13.414]             base::sink(type = "output", split = FALSE)
[01:29:13.414]             base::close(...future.stdout)
[01:29:13.414]         }, add = TRUE)
[01:29:13.414]     }
[01:29:13.414]     ...future.frame <- base::sys.nframe()
[01:29:13.414]     ...future.conditions <- base::list()
[01:29:13.414]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:13.414]     if (FALSE) {
[01:29:13.414]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:13.414]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:13.414]     }
[01:29:13.414]     ...future.result <- base::tryCatch({
[01:29:13.414]         base::withCallingHandlers({
[01:29:13.414]             ...future.value <- base::withVisible(base::local({
[01:29:13.414]                 ...future.makeSendCondition <- base::local({
[01:29:13.414]                   sendCondition <- NULL
[01:29:13.414]                   function(frame = 1L) {
[01:29:13.414]                     if (is.function(sendCondition)) 
[01:29:13.414]                       return(sendCondition)
[01:29:13.414]                     ns <- getNamespace("parallel")
[01:29:13.414]                     if (exists("sendData", mode = "function", 
[01:29:13.414]                       envir = ns)) {
[01:29:13.414]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:13.414]                         envir = ns)
[01:29:13.414]                       envir <- sys.frame(frame)
[01:29:13.414]                       master <- NULL
[01:29:13.414]                       while (!identical(envir, .GlobalEnv) && 
[01:29:13.414]                         !identical(envir, emptyenv())) {
[01:29:13.414]                         if (exists("master", mode = "list", envir = envir, 
[01:29:13.414]                           inherits = FALSE)) {
[01:29:13.414]                           master <- get("master", mode = "list", 
[01:29:13.414]                             envir = envir, inherits = FALSE)
[01:29:13.414]                           if (inherits(master, c("SOCKnode", 
[01:29:13.414]                             "SOCK0node"))) {
[01:29:13.414]                             sendCondition <<- function(cond) {
[01:29:13.414]                               data <- list(type = "VALUE", value = cond, 
[01:29:13.414]                                 success = TRUE)
[01:29:13.414]                               parallel_sendData(master, data)
[01:29:13.414]                             }
[01:29:13.414]                             return(sendCondition)
[01:29:13.414]                           }
[01:29:13.414]                         }
[01:29:13.414]                         frame <- frame + 1L
[01:29:13.414]                         envir <- sys.frame(frame)
[01:29:13.414]                       }
[01:29:13.414]                     }
[01:29:13.414]                     sendCondition <<- function(cond) NULL
[01:29:13.414]                   }
[01:29:13.414]                 })
[01:29:13.414]                 withCallingHandlers({
[01:29:13.414]                   1
[01:29:13.414]                 }, immediateCondition = function(cond) {
[01:29:13.414]                   sendCondition <- ...future.makeSendCondition()
[01:29:13.414]                   sendCondition(cond)
[01:29:13.414]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.414]                   {
[01:29:13.414]                     inherits <- base::inherits
[01:29:13.414]                     invokeRestart <- base::invokeRestart
[01:29:13.414]                     is.null <- base::is.null
[01:29:13.414]                     muffled <- FALSE
[01:29:13.414]                     if (inherits(cond, "message")) {
[01:29:13.414]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:13.414]                       if (muffled) 
[01:29:13.414]                         invokeRestart("muffleMessage")
[01:29:13.414]                     }
[01:29:13.414]                     else if (inherits(cond, "warning")) {
[01:29:13.414]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:13.414]                       if (muffled) 
[01:29:13.414]                         invokeRestart("muffleWarning")
[01:29:13.414]                     }
[01:29:13.414]                     else if (inherits(cond, "condition")) {
[01:29:13.414]                       if (!is.null(pattern)) {
[01:29:13.414]                         computeRestarts <- base::computeRestarts
[01:29:13.414]                         grepl <- base::grepl
[01:29:13.414]                         restarts <- computeRestarts(cond)
[01:29:13.414]                         for (restart in restarts) {
[01:29:13.414]                           name <- restart$name
[01:29:13.414]                           if (is.null(name)) 
[01:29:13.414]                             next
[01:29:13.414]                           if (!grepl(pattern, name)) 
[01:29:13.414]                             next
[01:29:13.414]                           invokeRestart(restart)
[01:29:13.414]                           muffled <- TRUE
[01:29:13.414]                           break
[01:29:13.414]                         }
[01:29:13.414]                       }
[01:29:13.414]                     }
[01:29:13.414]                     invisible(muffled)
[01:29:13.414]                   }
[01:29:13.414]                   muffleCondition(cond)
[01:29:13.414]                 })
[01:29:13.414]             }))
[01:29:13.414]             future::FutureResult(value = ...future.value$value, 
[01:29:13.414]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:13.414]                   ...future.rng), globalenv = if (FALSE) 
[01:29:13.414]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:13.414]                     ...future.globalenv.names))
[01:29:13.414]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:13.414]         }, condition = base::local({
[01:29:13.414]             c <- base::c
[01:29:13.414]             inherits <- base::inherits
[01:29:13.414]             invokeRestart <- base::invokeRestart
[01:29:13.414]             length <- base::length
[01:29:13.414]             list <- base::list
[01:29:13.414]             seq.int <- base::seq.int
[01:29:13.414]             signalCondition <- base::signalCondition
[01:29:13.414]             sys.calls <- base::sys.calls
[01:29:13.414]             `[[` <- base::`[[`
[01:29:13.414]             `+` <- base::`+`
[01:29:13.414]             `<<-` <- base::`<<-`
[01:29:13.414]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:13.414]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:13.414]                   3L)]
[01:29:13.414]             }
[01:29:13.414]             function(cond) {
[01:29:13.414]                 is_error <- inherits(cond, "error")
[01:29:13.414]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:13.414]                   NULL)
[01:29:13.414]                 if (is_error) {
[01:29:13.414]                   sessionInformation <- function() {
[01:29:13.414]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:13.414]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:13.414]                       search = base::search(), system = base::Sys.info())
[01:29:13.414]                   }
[01:29:13.414]                   ...future.conditions[[length(...future.conditions) + 
[01:29:13.414]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:13.414]                     cond$call), session = sessionInformation(), 
[01:29:13.414]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:13.414]                   signalCondition(cond)
[01:29:13.414]                 }
[01:29:13.414]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:13.414]                 "immediateCondition"))) {
[01:29:13.414]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:13.414]                   ...future.conditions[[length(...future.conditions) + 
[01:29:13.414]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:13.414]                   if (TRUE && !signal) {
[01:29:13.414]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.414]                     {
[01:29:13.414]                       inherits <- base::inherits
[01:29:13.414]                       invokeRestart <- base::invokeRestart
[01:29:13.414]                       is.null <- base::is.null
[01:29:13.414]                       muffled <- FALSE
[01:29:13.414]                       if (inherits(cond, "message")) {
[01:29:13.414]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:13.414]                         if (muffled) 
[01:29:13.414]                           invokeRestart("muffleMessage")
[01:29:13.414]                       }
[01:29:13.414]                       else if (inherits(cond, "warning")) {
[01:29:13.414]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:13.414]                         if (muffled) 
[01:29:13.414]                           invokeRestart("muffleWarning")
[01:29:13.414]                       }
[01:29:13.414]                       else if (inherits(cond, "condition")) {
[01:29:13.414]                         if (!is.null(pattern)) {
[01:29:13.414]                           computeRestarts <- base::computeRestarts
[01:29:13.414]                           grepl <- base::grepl
[01:29:13.414]                           restarts <- computeRestarts(cond)
[01:29:13.414]                           for (restart in restarts) {
[01:29:13.414]                             name <- restart$name
[01:29:13.414]                             if (is.null(name)) 
[01:29:13.414]                               next
[01:29:13.414]                             if (!grepl(pattern, name)) 
[01:29:13.414]                               next
[01:29:13.414]                             invokeRestart(restart)
[01:29:13.414]                             muffled <- TRUE
[01:29:13.414]                             break
[01:29:13.414]                           }
[01:29:13.414]                         }
[01:29:13.414]                       }
[01:29:13.414]                       invisible(muffled)
[01:29:13.414]                     }
[01:29:13.414]                     muffleCondition(cond, pattern = "^muffle")
[01:29:13.414]                   }
[01:29:13.414]                 }
[01:29:13.414]                 else {
[01:29:13.414]                   if (TRUE) {
[01:29:13.414]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.414]                     {
[01:29:13.414]                       inherits <- base::inherits
[01:29:13.414]                       invokeRestart <- base::invokeRestart
[01:29:13.414]                       is.null <- base::is.null
[01:29:13.414]                       muffled <- FALSE
[01:29:13.414]                       if (inherits(cond, "message")) {
[01:29:13.414]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:13.414]                         if (muffled) 
[01:29:13.414]                           invokeRestart("muffleMessage")
[01:29:13.414]                       }
[01:29:13.414]                       else if (inherits(cond, "warning")) {
[01:29:13.414]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:13.414]                         if (muffled) 
[01:29:13.414]                           invokeRestart("muffleWarning")
[01:29:13.414]                       }
[01:29:13.414]                       else if (inherits(cond, "condition")) {
[01:29:13.414]                         if (!is.null(pattern)) {
[01:29:13.414]                           computeRestarts <- base::computeRestarts
[01:29:13.414]                           grepl <- base::grepl
[01:29:13.414]                           restarts <- computeRestarts(cond)
[01:29:13.414]                           for (restart in restarts) {
[01:29:13.414]                             name <- restart$name
[01:29:13.414]                             if (is.null(name)) 
[01:29:13.414]                               next
[01:29:13.414]                             if (!grepl(pattern, name)) 
[01:29:13.414]                               next
[01:29:13.414]                             invokeRestart(restart)
[01:29:13.414]                             muffled <- TRUE
[01:29:13.414]                             break
[01:29:13.414]                           }
[01:29:13.414]                         }
[01:29:13.414]                       }
[01:29:13.414]                       invisible(muffled)
[01:29:13.414]                     }
[01:29:13.414]                     muffleCondition(cond, pattern = "^muffle")
[01:29:13.414]                   }
[01:29:13.414]                 }
[01:29:13.414]             }
[01:29:13.414]         }))
[01:29:13.414]     }, error = function(ex) {
[01:29:13.414]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:13.414]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:13.414]                 ...future.rng), started = ...future.startTime, 
[01:29:13.414]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:13.414]             version = "1.8"), class = "FutureResult")
[01:29:13.414]     }, finally = {
[01:29:13.414]         if (!identical(...future.workdir, getwd())) 
[01:29:13.414]             setwd(...future.workdir)
[01:29:13.414]         {
[01:29:13.414]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:13.414]                 ...future.oldOptions$nwarnings <- NULL
[01:29:13.414]             }
[01:29:13.414]             base::options(...future.oldOptions)
[01:29:13.414]             if (.Platform$OS.type == "windows") {
[01:29:13.414]                 old_names <- names(...future.oldEnvVars)
[01:29:13.414]                 envs <- base::Sys.getenv()
[01:29:13.414]                 names <- names(envs)
[01:29:13.414]                 common <- intersect(names, old_names)
[01:29:13.414]                 added <- setdiff(names, old_names)
[01:29:13.414]                 removed <- setdiff(old_names, names)
[01:29:13.414]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:13.414]                   envs[common]]
[01:29:13.414]                 NAMES <- toupper(changed)
[01:29:13.414]                 args <- list()
[01:29:13.414]                 for (kk in seq_along(NAMES)) {
[01:29:13.414]                   name <- changed[[kk]]
[01:29:13.414]                   NAME <- NAMES[[kk]]
[01:29:13.414]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.414]                     next
[01:29:13.414]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:13.414]                 }
[01:29:13.414]                 NAMES <- toupper(added)
[01:29:13.414]                 for (kk in seq_along(NAMES)) {
[01:29:13.414]                   name <- added[[kk]]
[01:29:13.414]                   NAME <- NAMES[[kk]]
[01:29:13.414]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.414]                     next
[01:29:13.414]                   args[[name]] <- ""
[01:29:13.414]                 }
[01:29:13.414]                 NAMES <- toupper(removed)
[01:29:13.414]                 for (kk in seq_along(NAMES)) {
[01:29:13.414]                   name <- removed[[kk]]
[01:29:13.414]                   NAME <- NAMES[[kk]]
[01:29:13.414]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.414]                     next
[01:29:13.414]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:13.414]                 }
[01:29:13.414]                 if (length(args) > 0) 
[01:29:13.414]                   base::do.call(base::Sys.setenv, args = args)
[01:29:13.414]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:13.414]             }
[01:29:13.414]             else {
[01:29:13.414]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:13.414]             }
[01:29:13.414]             {
[01:29:13.414]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:13.414]                   0L) {
[01:29:13.414]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:13.414]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:13.414]                   base::options(opts)
[01:29:13.414]                 }
[01:29:13.414]                 {
[01:29:13.414]                   {
[01:29:13.414]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:13.414]                     NULL
[01:29:13.414]                   }
[01:29:13.414]                   options(future.plan = NULL)
[01:29:13.414]                   if (is.na(NA_character_)) 
[01:29:13.414]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:13.414]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:13.414]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:13.414]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:13.414]                     envir = parent.frame()) 
[01:29:13.414]                   {
[01:29:13.414]                     if (is.function(workers)) 
[01:29:13.414]                       workers <- workers()
[01:29:13.414]                     workers <- structure(as.integer(workers), 
[01:29:13.414]                       class = class(workers))
[01:29:13.414]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:13.414]                       workers >= 1)
[01:29:13.414]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:13.414]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:13.414]                     }
[01:29:13.414]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:13.414]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:13.414]                       envir = envir)
[01:29:13.414]                     if (!future$lazy) 
[01:29:13.414]                       future <- run(future)
[01:29:13.414]                     invisible(future)
[01:29:13.414]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:13.414]                 }
[01:29:13.414]             }
[01:29:13.414]         }
[01:29:13.414]     })
[01:29:13.414]     if (TRUE) {
[01:29:13.414]         base::sink(type = "output", split = FALSE)
[01:29:13.414]         if (TRUE) {
[01:29:13.414]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:13.414]         }
[01:29:13.414]         else {
[01:29:13.414]             ...future.result["stdout"] <- base::list(NULL)
[01:29:13.414]         }
[01:29:13.414]         base::close(...future.stdout)
[01:29:13.414]         ...future.stdout <- NULL
[01:29:13.414]     }
[01:29:13.414]     ...future.result$conditions <- ...future.conditions
[01:29:13.414]     ...future.result$finished <- base::Sys.time()
[01:29:13.414]     ...future.result
[01:29:13.414] }
[01:29:13.420] MultisessionFuture started
[01:29:13.420] - Launch lazy future ... done
[01:29:13.421] run() for 'MultisessionFuture' ... done
[01:29:13.421] getGlobalsAndPackages() ...
[01:29:13.421] Searching for globals...
[01:29:13.421] 
[01:29:13.422] Searching for globals ... DONE
[01:29:13.422] - globals: [0] <none>
[01:29:13.422] getGlobalsAndPackages() ... DONE
[01:29:13.422] run() for 'Future' ...
[01:29:13.423] - state: 'created'
[01:29:13.423] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:13.441] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:13.441] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:13.441]   - Field: 'node'
[01:29:13.442]   - Field: 'label'
[01:29:13.442]   - Field: 'local'
[01:29:13.442]   - Field: 'owner'
[01:29:13.443]   - Field: 'envir'
[01:29:13.443]   - Field: 'workers'
[01:29:13.443]   - Field: 'packages'
[01:29:13.443]   - Field: 'gc'
[01:29:13.444]   - Field: 'conditions'
[01:29:13.444]   - Field: 'persistent'
[01:29:13.444]   - Field: 'expr'
[01:29:13.445]   - Field: 'uuid'
[01:29:13.445]   - Field: 'seed'
[01:29:13.445]   - Field: 'version'
[01:29:13.445]   - Field: 'result'
[01:29:13.446]   - Field: 'asynchronous'
[01:29:13.446]   - Field: 'calls'
[01:29:13.446]   - Field: 'globals'
[01:29:13.447]   - Field: 'stdout'
[01:29:13.447]   - Field: 'earlySignal'
[01:29:13.447]   - Field: 'lazy'
[01:29:13.447]   - Field: 'state'
[01:29:13.448] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:13.448] - Launch lazy future ...
[01:29:13.449] Packages needed by the future expression (n = 0): <none>
[01:29:13.449] Packages needed by future strategies (n = 0): <none>
[01:29:13.450] {
[01:29:13.450]     {
[01:29:13.450]         {
[01:29:13.450]             ...future.startTime <- base::Sys.time()
[01:29:13.450]             {
[01:29:13.450]                 {
[01:29:13.450]                   {
[01:29:13.450]                     {
[01:29:13.450]                       base::local({
[01:29:13.450]                         has_future <- base::requireNamespace("future", 
[01:29:13.450]                           quietly = TRUE)
[01:29:13.450]                         if (has_future) {
[01:29:13.450]                           ns <- base::getNamespace("future")
[01:29:13.450]                           version <- ns[[".package"]][["version"]]
[01:29:13.450]                           if (is.null(version)) 
[01:29:13.450]                             version <- utils::packageVersion("future")
[01:29:13.450]                         }
[01:29:13.450]                         else {
[01:29:13.450]                           version <- NULL
[01:29:13.450]                         }
[01:29:13.450]                         if (!has_future || version < "1.8.0") {
[01:29:13.450]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:13.450]                             "", base::R.version$version.string), 
[01:29:13.450]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:13.450]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:13.450]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:13.450]                               "release", "version")], collapse = " "), 
[01:29:13.450]                             hostname = base::Sys.info()[["nodename"]])
[01:29:13.450]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:13.450]                             info)
[01:29:13.450]                           info <- base::paste(info, collapse = "; ")
[01:29:13.450]                           if (!has_future) {
[01:29:13.450]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:13.450]                               info)
[01:29:13.450]                           }
[01:29:13.450]                           else {
[01:29:13.450]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:13.450]                               info, version)
[01:29:13.450]                           }
[01:29:13.450]                           base::stop(msg)
[01:29:13.450]                         }
[01:29:13.450]                       })
[01:29:13.450]                     }
[01:29:13.450]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:13.450]                     base::options(mc.cores = 1L)
[01:29:13.450]                   }
[01:29:13.450]                   options(future.plan = NULL)
[01:29:13.450]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:13.450]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:13.450]                 }
[01:29:13.450]                 ...future.workdir <- getwd()
[01:29:13.450]             }
[01:29:13.450]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:13.450]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:13.450]         }
[01:29:13.450]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:13.450]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:13.450]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:13.450]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:13.450]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:13.450]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:13.450]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:13.450]             base::names(...future.oldOptions))
[01:29:13.450]     }
[01:29:13.450]     if (FALSE) {
[01:29:13.450]     }
[01:29:13.450]     else {
[01:29:13.450]         if (TRUE) {
[01:29:13.450]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:13.450]                 open = "w")
[01:29:13.450]         }
[01:29:13.450]         else {
[01:29:13.450]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:13.450]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:13.450]         }
[01:29:13.450]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:13.450]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:13.450]             base::sink(type = "output", split = FALSE)
[01:29:13.450]             base::close(...future.stdout)
[01:29:13.450]         }, add = TRUE)
[01:29:13.450]     }
[01:29:13.450]     ...future.frame <- base::sys.nframe()
[01:29:13.450]     ...future.conditions <- base::list()
[01:29:13.450]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:13.450]     if (FALSE) {
[01:29:13.450]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:13.450]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:13.450]     }
[01:29:13.450]     ...future.result <- base::tryCatch({
[01:29:13.450]         base::withCallingHandlers({
[01:29:13.450]             ...future.value <- base::withVisible(base::local({
[01:29:13.450]                 ...future.makeSendCondition <- base::local({
[01:29:13.450]                   sendCondition <- NULL
[01:29:13.450]                   function(frame = 1L) {
[01:29:13.450]                     if (is.function(sendCondition)) 
[01:29:13.450]                       return(sendCondition)
[01:29:13.450]                     ns <- getNamespace("parallel")
[01:29:13.450]                     if (exists("sendData", mode = "function", 
[01:29:13.450]                       envir = ns)) {
[01:29:13.450]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:13.450]                         envir = ns)
[01:29:13.450]                       envir <- sys.frame(frame)
[01:29:13.450]                       master <- NULL
[01:29:13.450]                       while (!identical(envir, .GlobalEnv) && 
[01:29:13.450]                         !identical(envir, emptyenv())) {
[01:29:13.450]                         if (exists("master", mode = "list", envir = envir, 
[01:29:13.450]                           inherits = FALSE)) {
[01:29:13.450]                           master <- get("master", mode = "list", 
[01:29:13.450]                             envir = envir, inherits = FALSE)
[01:29:13.450]                           if (inherits(master, c("SOCKnode", 
[01:29:13.450]                             "SOCK0node"))) {
[01:29:13.450]                             sendCondition <<- function(cond) {
[01:29:13.450]                               data <- list(type = "VALUE", value = cond, 
[01:29:13.450]                                 success = TRUE)
[01:29:13.450]                               parallel_sendData(master, data)
[01:29:13.450]                             }
[01:29:13.450]                             return(sendCondition)
[01:29:13.450]                           }
[01:29:13.450]                         }
[01:29:13.450]                         frame <- frame + 1L
[01:29:13.450]                         envir <- sys.frame(frame)
[01:29:13.450]                       }
[01:29:13.450]                     }
[01:29:13.450]                     sendCondition <<- function(cond) NULL
[01:29:13.450]                   }
[01:29:13.450]                 })
[01:29:13.450]                 withCallingHandlers({
[01:29:13.450]                   2
[01:29:13.450]                 }, immediateCondition = function(cond) {
[01:29:13.450]                   sendCondition <- ...future.makeSendCondition()
[01:29:13.450]                   sendCondition(cond)
[01:29:13.450]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.450]                   {
[01:29:13.450]                     inherits <- base::inherits
[01:29:13.450]                     invokeRestart <- base::invokeRestart
[01:29:13.450]                     is.null <- base::is.null
[01:29:13.450]                     muffled <- FALSE
[01:29:13.450]                     if (inherits(cond, "message")) {
[01:29:13.450]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:13.450]                       if (muffled) 
[01:29:13.450]                         invokeRestart("muffleMessage")
[01:29:13.450]                     }
[01:29:13.450]                     else if (inherits(cond, "warning")) {
[01:29:13.450]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:13.450]                       if (muffled) 
[01:29:13.450]                         invokeRestart("muffleWarning")
[01:29:13.450]                     }
[01:29:13.450]                     else if (inherits(cond, "condition")) {
[01:29:13.450]                       if (!is.null(pattern)) {
[01:29:13.450]                         computeRestarts <- base::computeRestarts
[01:29:13.450]                         grepl <- base::grepl
[01:29:13.450]                         restarts <- computeRestarts(cond)
[01:29:13.450]                         for (restart in restarts) {
[01:29:13.450]                           name <- restart$name
[01:29:13.450]                           if (is.null(name)) 
[01:29:13.450]                             next
[01:29:13.450]                           if (!grepl(pattern, name)) 
[01:29:13.450]                             next
[01:29:13.450]                           invokeRestart(restart)
[01:29:13.450]                           muffled <- TRUE
[01:29:13.450]                           break
[01:29:13.450]                         }
[01:29:13.450]                       }
[01:29:13.450]                     }
[01:29:13.450]                     invisible(muffled)
[01:29:13.450]                   }
[01:29:13.450]                   muffleCondition(cond)
[01:29:13.450]                 })
[01:29:13.450]             }))
[01:29:13.450]             future::FutureResult(value = ...future.value$value, 
[01:29:13.450]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:13.450]                   ...future.rng), globalenv = if (FALSE) 
[01:29:13.450]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:13.450]                     ...future.globalenv.names))
[01:29:13.450]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:13.450]         }, condition = base::local({
[01:29:13.450]             c <- base::c
[01:29:13.450]             inherits <- base::inherits
[01:29:13.450]             invokeRestart <- base::invokeRestart
[01:29:13.450]             length <- base::length
[01:29:13.450]             list <- base::list
[01:29:13.450]             seq.int <- base::seq.int
[01:29:13.450]             signalCondition <- base::signalCondition
[01:29:13.450]             sys.calls <- base::sys.calls
[01:29:13.450]             `[[` <- base::`[[`
[01:29:13.450]             `+` <- base::`+`
[01:29:13.450]             `<<-` <- base::`<<-`
[01:29:13.450]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:13.450]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:13.450]                   3L)]
[01:29:13.450]             }
[01:29:13.450]             function(cond) {
[01:29:13.450]                 is_error <- inherits(cond, "error")
[01:29:13.450]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:13.450]                   NULL)
[01:29:13.450]                 if (is_error) {
[01:29:13.450]                   sessionInformation <- function() {
[01:29:13.450]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:13.450]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:13.450]                       search = base::search(), system = base::Sys.info())
[01:29:13.450]                   }
[01:29:13.450]                   ...future.conditions[[length(...future.conditions) + 
[01:29:13.450]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:13.450]                     cond$call), session = sessionInformation(), 
[01:29:13.450]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:13.450]                   signalCondition(cond)
[01:29:13.450]                 }
[01:29:13.450]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:13.450]                 "immediateCondition"))) {
[01:29:13.450]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:13.450]                   ...future.conditions[[length(...future.conditions) + 
[01:29:13.450]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:13.450]                   if (TRUE && !signal) {
[01:29:13.450]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.450]                     {
[01:29:13.450]                       inherits <- base::inherits
[01:29:13.450]                       invokeRestart <- base::invokeRestart
[01:29:13.450]                       is.null <- base::is.null
[01:29:13.450]                       muffled <- FALSE
[01:29:13.450]                       if (inherits(cond, "message")) {
[01:29:13.450]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:13.450]                         if (muffled) 
[01:29:13.450]                           invokeRestart("muffleMessage")
[01:29:13.450]                       }
[01:29:13.450]                       else if (inherits(cond, "warning")) {
[01:29:13.450]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:13.450]                         if (muffled) 
[01:29:13.450]                           invokeRestart("muffleWarning")
[01:29:13.450]                       }
[01:29:13.450]                       else if (inherits(cond, "condition")) {
[01:29:13.450]                         if (!is.null(pattern)) {
[01:29:13.450]                           computeRestarts <- base::computeRestarts
[01:29:13.450]                           grepl <- base::grepl
[01:29:13.450]                           restarts <- computeRestarts(cond)
[01:29:13.450]                           for (restart in restarts) {
[01:29:13.450]                             name <- restart$name
[01:29:13.450]                             if (is.null(name)) 
[01:29:13.450]                               next
[01:29:13.450]                             if (!grepl(pattern, name)) 
[01:29:13.450]                               next
[01:29:13.450]                             invokeRestart(restart)
[01:29:13.450]                             muffled <- TRUE
[01:29:13.450]                             break
[01:29:13.450]                           }
[01:29:13.450]                         }
[01:29:13.450]                       }
[01:29:13.450]                       invisible(muffled)
[01:29:13.450]                     }
[01:29:13.450]                     muffleCondition(cond, pattern = "^muffle")
[01:29:13.450]                   }
[01:29:13.450]                 }
[01:29:13.450]                 else {
[01:29:13.450]                   if (TRUE) {
[01:29:13.450]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.450]                     {
[01:29:13.450]                       inherits <- base::inherits
[01:29:13.450]                       invokeRestart <- base::invokeRestart
[01:29:13.450]                       is.null <- base::is.null
[01:29:13.450]                       muffled <- FALSE
[01:29:13.450]                       if (inherits(cond, "message")) {
[01:29:13.450]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:13.450]                         if (muffled) 
[01:29:13.450]                           invokeRestart("muffleMessage")
[01:29:13.450]                       }
[01:29:13.450]                       else if (inherits(cond, "warning")) {
[01:29:13.450]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:13.450]                         if (muffled) 
[01:29:13.450]                           invokeRestart("muffleWarning")
[01:29:13.450]                       }
[01:29:13.450]                       else if (inherits(cond, "condition")) {
[01:29:13.450]                         if (!is.null(pattern)) {
[01:29:13.450]                           computeRestarts <- base::computeRestarts
[01:29:13.450]                           grepl <- base::grepl
[01:29:13.450]                           restarts <- computeRestarts(cond)
[01:29:13.450]                           for (restart in restarts) {
[01:29:13.450]                             name <- restart$name
[01:29:13.450]                             if (is.null(name)) 
[01:29:13.450]                               next
[01:29:13.450]                             if (!grepl(pattern, name)) 
[01:29:13.450]                               next
[01:29:13.450]                             invokeRestart(restart)
[01:29:13.450]                             muffled <- TRUE
[01:29:13.450]                             break
[01:29:13.450]                           }
[01:29:13.450]                         }
[01:29:13.450]                       }
[01:29:13.450]                       invisible(muffled)
[01:29:13.450]                     }
[01:29:13.450]                     muffleCondition(cond, pattern = "^muffle")
[01:29:13.450]                   }
[01:29:13.450]                 }
[01:29:13.450]             }
[01:29:13.450]         }))
[01:29:13.450]     }, error = function(ex) {
[01:29:13.450]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:13.450]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:13.450]                 ...future.rng), started = ...future.startTime, 
[01:29:13.450]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:13.450]             version = "1.8"), class = "FutureResult")
[01:29:13.450]     }, finally = {
[01:29:13.450]         if (!identical(...future.workdir, getwd())) 
[01:29:13.450]             setwd(...future.workdir)
[01:29:13.450]         {
[01:29:13.450]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:13.450]                 ...future.oldOptions$nwarnings <- NULL
[01:29:13.450]             }
[01:29:13.450]             base::options(...future.oldOptions)
[01:29:13.450]             if (.Platform$OS.type == "windows") {
[01:29:13.450]                 old_names <- names(...future.oldEnvVars)
[01:29:13.450]                 envs <- base::Sys.getenv()
[01:29:13.450]                 names <- names(envs)
[01:29:13.450]                 common <- intersect(names, old_names)
[01:29:13.450]                 added <- setdiff(names, old_names)
[01:29:13.450]                 removed <- setdiff(old_names, names)
[01:29:13.450]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:13.450]                   envs[common]]
[01:29:13.450]                 NAMES <- toupper(changed)
[01:29:13.450]                 args <- list()
[01:29:13.450]                 for (kk in seq_along(NAMES)) {
[01:29:13.450]                   name <- changed[[kk]]
[01:29:13.450]                   NAME <- NAMES[[kk]]
[01:29:13.450]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.450]                     next
[01:29:13.450]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:13.450]                 }
[01:29:13.450]                 NAMES <- toupper(added)
[01:29:13.450]                 for (kk in seq_along(NAMES)) {
[01:29:13.450]                   name <- added[[kk]]
[01:29:13.450]                   NAME <- NAMES[[kk]]
[01:29:13.450]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.450]                     next
[01:29:13.450]                   args[[name]] <- ""
[01:29:13.450]                 }
[01:29:13.450]                 NAMES <- toupper(removed)
[01:29:13.450]                 for (kk in seq_along(NAMES)) {
[01:29:13.450]                   name <- removed[[kk]]
[01:29:13.450]                   NAME <- NAMES[[kk]]
[01:29:13.450]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.450]                     next
[01:29:13.450]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:13.450]                 }
[01:29:13.450]                 if (length(args) > 0) 
[01:29:13.450]                   base::do.call(base::Sys.setenv, args = args)
[01:29:13.450]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:13.450]             }
[01:29:13.450]             else {
[01:29:13.450]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:13.450]             }
[01:29:13.450]             {
[01:29:13.450]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:13.450]                   0L) {
[01:29:13.450]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:13.450]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:13.450]                   base::options(opts)
[01:29:13.450]                 }
[01:29:13.450]                 {
[01:29:13.450]                   {
[01:29:13.450]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:13.450]                     NULL
[01:29:13.450]                   }
[01:29:13.450]                   options(future.plan = NULL)
[01:29:13.450]                   if (is.na(NA_character_)) 
[01:29:13.450]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:13.450]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:13.450]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:13.450]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:13.450]                     envir = parent.frame()) 
[01:29:13.450]                   {
[01:29:13.450]                     if (is.function(workers)) 
[01:29:13.450]                       workers <- workers()
[01:29:13.450]                     workers <- structure(as.integer(workers), 
[01:29:13.450]                       class = class(workers))
[01:29:13.450]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:13.450]                       workers >= 1)
[01:29:13.450]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:13.450]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:13.450]                     }
[01:29:13.450]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:13.450]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:13.450]                       envir = envir)
[01:29:13.450]                     if (!future$lazy) 
[01:29:13.450]                       future <- run(future)
[01:29:13.450]                     invisible(future)
[01:29:13.450]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:13.450]                 }
[01:29:13.450]             }
[01:29:13.450]         }
[01:29:13.450]     })
[01:29:13.450]     if (TRUE) {
[01:29:13.450]         base::sink(type = "output", split = FALSE)
[01:29:13.450]         if (TRUE) {
[01:29:13.450]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:13.450]         }
[01:29:13.450]         else {
[01:29:13.450]             ...future.result["stdout"] <- base::list(NULL)
[01:29:13.450]         }
[01:29:13.450]         base::close(...future.stdout)
[01:29:13.450]         ...future.stdout <- NULL
[01:29:13.450]     }
[01:29:13.450]     ...future.result$conditions <- ...future.conditions
[01:29:13.450]     ...future.result$finished <- base::Sys.time()
[01:29:13.450]     ...future.result
[01:29:13.450] }
[01:29:13.459] MultisessionFuture started
[01:29:13.459] - Launch lazy future ... done
[01:29:13.459] run() for 'MultisessionFuture' ... done
[01:29:13.461] resolve() on environment ...
[01:29:13.461]  recursive: 0
[01:29:13.462]  elements: [3] 'a', 'b', 'c'
[01:29:13.462] receiveMessageFromWorker() for ClusterFuture ...
[01:29:13.463] - Validating connection of MultisessionFuture
[01:29:13.463] - received message: FutureResult
[01:29:13.464] - Received FutureResult
[01:29:13.464] - Erased future from FutureRegistry
[01:29:13.464] result() for ClusterFuture ...
[01:29:13.464] - result already collected: FutureResult
[01:29:13.465] result() for ClusterFuture ... done
[01:29:13.465] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:13.465] Future #1
[01:29:13.466]  length: 2 (resolved future 1)
[01:29:13.479] receiveMessageFromWorker() for ClusterFuture ...
[01:29:13.480] - Validating connection of MultisessionFuture
[01:29:13.480] - received message: FutureResult
[01:29:13.480] - Received FutureResult
[01:29:13.480] - Erased future from FutureRegistry
[01:29:13.480] result() for ClusterFuture ...
[01:29:13.481] - result already collected: FutureResult
[01:29:13.481] result() for ClusterFuture ... done
[01:29:13.481] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:13.481] Future #2
[01:29:13.481]  length: 1 (resolved future 2)
[01:29:13.481]  length: 0 (resolved future 3)
[01:29:13.482] resolve() on environment ... DONE
[01:29:13.482] getGlobalsAndPackages() ...
[01:29:13.483] Searching for globals...
[01:29:13.483] - globals found: [1] '{'
[01:29:13.484] Searching for globals ... DONE
[01:29:13.484] Resolving globals: FALSE
[01:29:13.484] 
[01:29:13.484] 
[01:29:13.485] getGlobalsAndPackages() ... DONE
[01:29:13.485] run() for 'Future' ...
[01:29:13.485] - state: 'created'
[01:29:13.485] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:13.500] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:13.500] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:13.500]   - Field: 'node'
[01:29:13.501]   - Field: 'label'
[01:29:13.501]   - Field: 'local'
[01:29:13.501]   - Field: 'owner'
[01:29:13.501]   - Field: 'envir'
[01:29:13.501]   - Field: 'workers'
[01:29:13.502]   - Field: 'packages'
[01:29:13.502]   - Field: 'gc'
[01:29:13.502]   - Field: 'conditions'
[01:29:13.502]   - Field: 'persistent'
[01:29:13.502]   - Field: 'expr'
[01:29:13.503]   - Field: 'uuid'
[01:29:13.503]   - Field: 'seed'
[01:29:13.503]   - Field: 'version'
[01:29:13.503]   - Field: 'result'
[01:29:13.503]   - Field: 'asynchronous'
[01:29:13.503]   - Field: 'calls'
[01:29:13.504]   - Field: 'globals'
[01:29:13.504]   - Field: 'stdout'
[01:29:13.504]   - Field: 'earlySignal'
[01:29:13.504]   - Field: 'lazy'
[01:29:13.504]   - Field: 'state'
[01:29:13.505] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:13.505] - Launch lazy future ...
[01:29:13.505] Packages needed by the future expression (n = 0): <none>
[01:29:13.505] Packages needed by future strategies (n = 0): <none>
[01:29:13.506] {
[01:29:13.506]     {
[01:29:13.506]         {
[01:29:13.506]             ...future.startTime <- base::Sys.time()
[01:29:13.506]             {
[01:29:13.506]                 {
[01:29:13.506]                   {
[01:29:13.506]                     {
[01:29:13.506]                       base::local({
[01:29:13.506]                         has_future <- base::requireNamespace("future", 
[01:29:13.506]                           quietly = TRUE)
[01:29:13.506]                         if (has_future) {
[01:29:13.506]                           ns <- base::getNamespace("future")
[01:29:13.506]                           version <- ns[[".package"]][["version"]]
[01:29:13.506]                           if (is.null(version)) 
[01:29:13.506]                             version <- utils::packageVersion("future")
[01:29:13.506]                         }
[01:29:13.506]                         else {
[01:29:13.506]                           version <- NULL
[01:29:13.506]                         }
[01:29:13.506]                         if (!has_future || version < "1.8.0") {
[01:29:13.506]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:13.506]                             "", base::R.version$version.string), 
[01:29:13.506]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:13.506]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:13.506]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:13.506]                               "release", "version")], collapse = " "), 
[01:29:13.506]                             hostname = base::Sys.info()[["nodename"]])
[01:29:13.506]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:13.506]                             info)
[01:29:13.506]                           info <- base::paste(info, collapse = "; ")
[01:29:13.506]                           if (!has_future) {
[01:29:13.506]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:13.506]                               info)
[01:29:13.506]                           }
[01:29:13.506]                           else {
[01:29:13.506]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:13.506]                               info, version)
[01:29:13.506]                           }
[01:29:13.506]                           base::stop(msg)
[01:29:13.506]                         }
[01:29:13.506]                       })
[01:29:13.506]                     }
[01:29:13.506]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:13.506]                     base::options(mc.cores = 1L)
[01:29:13.506]                   }
[01:29:13.506]                   options(future.plan = NULL)
[01:29:13.506]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:13.506]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:13.506]                 }
[01:29:13.506]                 ...future.workdir <- getwd()
[01:29:13.506]             }
[01:29:13.506]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:13.506]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:13.506]         }
[01:29:13.506]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:13.506]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:13.506]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:13.506]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:13.506]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:13.506]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:13.506]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:13.506]             base::names(...future.oldOptions))
[01:29:13.506]     }
[01:29:13.506]     if (FALSE) {
[01:29:13.506]     }
[01:29:13.506]     else {
[01:29:13.506]         if (TRUE) {
[01:29:13.506]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:13.506]                 open = "w")
[01:29:13.506]         }
[01:29:13.506]         else {
[01:29:13.506]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:13.506]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:13.506]         }
[01:29:13.506]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:13.506]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:13.506]             base::sink(type = "output", split = FALSE)
[01:29:13.506]             base::close(...future.stdout)
[01:29:13.506]         }, add = TRUE)
[01:29:13.506]     }
[01:29:13.506]     ...future.frame <- base::sys.nframe()
[01:29:13.506]     ...future.conditions <- base::list()
[01:29:13.506]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:13.506]     if (FALSE) {
[01:29:13.506]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:13.506]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:13.506]     }
[01:29:13.506]     ...future.result <- base::tryCatch({
[01:29:13.506]         base::withCallingHandlers({
[01:29:13.506]             ...future.value <- base::withVisible(base::local({
[01:29:13.506]                 ...future.makeSendCondition <- base::local({
[01:29:13.506]                   sendCondition <- NULL
[01:29:13.506]                   function(frame = 1L) {
[01:29:13.506]                     if (is.function(sendCondition)) 
[01:29:13.506]                       return(sendCondition)
[01:29:13.506]                     ns <- getNamespace("parallel")
[01:29:13.506]                     if (exists("sendData", mode = "function", 
[01:29:13.506]                       envir = ns)) {
[01:29:13.506]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:13.506]                         envir = ns)
[01:29:13.506]                       envir <- sys.frame(frame)
[01:29:13.506]                       master <- NULL
[01:29:13.506]                       while (!identical(envir, .GlobalEnv) && 
[01:29:13.506]                         !identical(envir, emptyenv())) {
[01:29:13.506]                         if (exists("master", mode = "list", envir = envir, 
[01:29:13.506]                           inherits = FALSE)) {
[01:29:13.506]                           master <- get("master", mode = "list", 
[01:29:13.506]                             envir = envir, inherits = FALSE)
[01:29:13.506]                           if (inherits(master, c("SOCKnode", 
[01:29:13.506]                             "SOCK0node"))) {
[01:29:13.506]                             sendCondition <<- function(cond) {
[01:29:13.506]                               data <- list(type = "VALUE", value = cond, 
[01:29:13.506]                                 success = TRUE)
[01:29:13.506]                               parallel_sendData(master, data)
[01:29:13.506]                             }
[01:29:13.506]                             return(sendCondition)
[01:29:13.506]                           }
[01:29:13.506]                         }
[01:29:13.506]                         frame <- frame + 1L
[01:29:13.506]                         envir <- sys.frame(frame)
[01:29:13.506]                       }
[01:29:13.506]                     }
[01:29:13.506]                     sendCondition <<- function(cond) NULL
[01:29:13.506]                   }
[01:29:13.506]                 })
[01:29:13.506]                 withCallingHandlers({
[01:29:13.506]                   {
[01:29:13.506]                     1
[01:29:13.506]                   }
[01:29:13.506]                 }, immediateCondition = function(cond) {
[01:29:13.506]                   sendCondition <- ...future.makeSendCondition()
[01:29:13.506]                   sendCondition(cond)
[01:29:13.506]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.506]                   {
[01:29:13.506]                     inherits <- base::inherits
[01:29:13.506]                     invokeRestart <- base::invokeRestart
[01:29:13.506]                     is.null <- base::is.null
[01:29:13.506]                     muffled <- FALSE
[01:29:13.506]                     if (inherits(cond, "message")) {
[01:29:13.506]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:13.506]                       if (muffled) 
[01:29:13.506]                         invokeRestart("muffleMessage")
[01:29:13.506]                     }
[01:29:13.506]                     else if (inherits(cond, "warning")) {
[01:29:13.506]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:13.506]                       if (muffled) 
[01:29:13.506]                         invokeRestart("muffleWarning")
[01:29:13.506]                     }
[01:29:13.506]                     else if (inherits(cond, "condition")) {
[01:29:13.506]                       if (!is.null(pattern)) {
[01:29:13.506]                         computeRestarts <- base::computeRestarts
[01:29:13.506]                         grepl <- base::grepl
[01:29:13.506]                         restarts <- computeRestarts(cond)
[01:29:13.506]                         for (restart in restarts) {
[01:29:13.506]                           name <- restart$name
[01:29:13.506]                           if (is.null(name)) 
[01:29:13.506]                             next
[01:29:13.506]                           if (!grepl(pattern, name)) 
[01:29:13.506]                             next
[01:29:13.506]                           invokeRestart(restart)
[01:29:13.506]                           muffled <- TRUE
[01:29:13.506]                           break
[01:29:13.506]                         }
[01:29:13.506]                       }
[01:29:13.506]                     }
[01:29:13.506]                     invisible(muffled)
[01:29:13.506]                   }
[01:29:13.506]                   muffleCondition(cond)
[01:29:13.506]                 })
[01:29:13.506]             }))
[01:29:13.506]             future::FutureResult(value = ...future.value$value, 
[01:29:13.506]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:13.506]                   ...future.rng), globalenv = if (FALSE) 
[01:29:13.506]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:13.506]                     ...future.globalenv.names))
[01:29:13.506]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:13.506]         }, condition = base::local({
[01:29:13.506]             c <- base::c
[01:29:13.506]             inherits <- base::inherits
[01:29:13.506]             invokeRestart <- base::invokeRestart
[01:29:13.506]             length <- base::length
[01:29:13.506]             list <- base::list
[01:29:13.506]             seq.int <- base::seq.int
[01:29:13.506]             signalCondition <- base::signalCondition
[01:29:13.506]             sys.calls <- base::sys.calls
[01:29:13.506]             `[[` <- base::`[[`
[01:29:13.506]             `+` <- base::`+`
[01:29:13.506]             `<<-` <- base::`<<-`
[01:29:13.506]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:13.506]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:13.506]                   3L)]
[01:29:13.506]             }
[01:29:13.506]             function(cond) {
[01:29:13.506]                 is_error <- inherits(cond, "error")
[01:29:13.506]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:13.506]                   NULL)
[01:29:13.506]                 if (is_error) {
[01:29:13.506]                   sessionInformation <- function() {
[01:29:13.506]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:13.506]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:13.506]                       search = base::search(), system = base::Sys.info())
[01:29:13.506]                   }
[01:29:13.506]                   ...future.conditions[[length(...future.conditions) + 
[01:29:13.506]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:13.506]                     cond$call), session = sessionInformation(), 
[01:29:13.506]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:13.506]                   signalCondition(cond)
[01:29:13.506]                 }
[01:29:13.506]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:13.506]                 "immediateCondition"))) {
[01:29:13.506]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:13.506]                   ...future.conditions[[length(...future.conditions) + 
[01:29:13.506]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:13.506]                   if (TRUE && !signal) {
[01:29:13.506]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.506]                     {
[01:29:13.506]                       inherits <- base::inherits
[01:29:13.506]                       invokeRestart <- base::invokeRestart
[01:29:13.506]                       is.null <- base::is.null
[01:29:13.506]                       muffled <- FALSE
[01:29:13.506]                       if (inherits(cond, "message")) {
[01:29:13.506]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:13.506]                         if (muffled) 
[01:29:13.506]                           invokeRestart("muffleMessage")
[01:29:13.506]                       }
[01:29:13.506]                       else if (inherits(cond, "warning")) {
[01:29:13.506]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:13.506]                         if (muffled) 
[01:29:13.506]                           invokeRestart("muffleWarning")
[01:29:13.506]                       }
[01:29:13.506]                       else if (inherits(cond, "condition")) {
[01:29:13.506]                         if (!is.null(pattern)) {
[01:29:13.506]                           computeRestarts <- base::computeRestarts
[01:29:13.506]                           grepl <- base::grepl
[01:29:13.506]                           restarts <- computeRestarts(cond)
[01:29:13.506]                           for (restart in restarts) {
[01:29:13.506]                             name <- restart$name
[01:29:13.506]                             if (is.null(name)) 
[01:29:13.506]                               next
[01:29:13.506]                             if (!grepl(pattern, name)) 
[01:29:13.506]                               next
[01:29:13.506]                             invokeRestart(restart)
[01:29:13.506]                             muffled <- TRUE
[01:29:13.506]                             break
[01:29:13.506]                           }
[01:29:13.506]                         }
[01:29:13.506]                       }
[01:29:13.506]                       invisible(muffled)
[01:29:13.506]                     }
[01:29:13.506]                     muffleCondition(cond, pattern = "^muffle")
[01:29:13.506]                   }
[01:29:13.506]                 }
[01:29:13.506]                 else {
[01:29:13.506]                   if (TRUE) {
[01:29:13.506]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.506]                     {
[01:29:13.506]                       inherits <- base::inherits
[01:29:13.506]                       invokeRestart <- base::invokeRestart
[01:29:13.506]                       is.null <- base::is.null
[01:29:13.506]                       muffled <- FALSE
[01:29:13.506]                       if (inherits(cond, "message")) {
[01:29:13.506]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:13.506]                         if (muffled) 
[01:29:13.506]                           invokeRestart("muffleMessage")
[01:29:13.506]                       }
[01:29:13.506]                       else if (inherits(cond, "warning")) {
[01:29:13.506]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:13.506]                         if (muffled) 
[01:29:13.506]                           invokeRestart("muffleWarning")
[01:29:13.506]                       }
[01:29:13.506]                       else if (inherits(cond, "condition")) {
[01:29:13.506]                         if (!is.null(pattern)) {
[01:29:13.506]                           computeRestarts <- base::computeRestarts
[01:29:13.506]                           grepl <- base::grepl
[01:29:13.506]                           restarts <- computeRestarts(cond)
[01:29:13.506]                           for (restart in restarts) {
[01:29:13.506]                             name <- restart$name
[01:29:13.506]                             if (is.null(name)) 
[01:29:13.506]                               next
[01:29:13.506]                             if (!grepl(pattern, name)) 
[01:29:13.506]                               next
[01:29:13.506]                             invokeRestart(restart)
[01:29:13.506]                             muffled <- TRUE
[01:29:13.506]                             break
[01:29:13.506]                           }
[01:29:13.506]                         }
[01:29:13.506]                       }
[01:29:13.506]                       invisible(muffled)
[01:29:13.506]                     }
[01:29:13.506]                     muffleCondition(cond, pattern = "^muffle")
[01:29:13.506]                   }
[01:29:13.506]                 }
[01:29:13.506]             }
[01:29:13.506]         }))
[01:29:13.506]     }, error = function(ex) {
[01:29:13.506]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:13.506]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:13.506]                 ...future.rng), started = ...future.startTime, 
[01:29:13.506]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:13.506]             version = "1.8"), class = "FutureResult")
[01:29:13.506]     }, finally = {
[01:29:13.506]         if (!identical(...future.workdir, getwd())) 
[01:29:13.506]             setwd(...future.workdir)
[01:29:13.506]         {
[01:29:13.506]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:13.506]                 ...future.oldOptions$nwarnings <- NULL
[01:29:13.506]             }
[01:29:13.506]             base::options(...future.oldOptions)
[01:29:13.506]             if (.Platform$OS.type == "windows") {
[01:29:13.506]                 old_names <- names(...future.oldEnvVars)
[01:29:13.506]                 envs <- base::Sys.getenv()
[01:29:13.506]                 names <- names(envs)
[01:29:13.506]                 common <- intersect(names, old_names)
[01:29:13.506]                 added <- setdiff(names, old_names)
[01:29:13.506]                 removed <- setdiff(old_names, names)
[01:29:13.506]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:13.506]                   envs[common]]
[01:29:13.506]                 NAMES <- toupper(changed)
[01:29:13.506]                 args <- list()
[01:29:13.506]                 for (kk in seq_along(NAMES)) {
[01:29:13.506]                   name <- changed[[kk]]
[01:29:13.506]                   NAME <- NAMES[[kk]]
[01:29:13.506]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.506]                     next
[01:29:13.506]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:13.506]                 }
[01:29:13.506]                 NAMES <- toupper(added)
[01:29:13.506]                 for (kk in seq_along(NAMES)) {
[01:29:13.506]                   name <- added[[kk]]
[01:29:13.506]                   NAME <- NAMES[[kk]]
[01:29:13.506]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.506]                     next
[01:29:13.506]                   args[[name]] <- ""
[01:29:13.506]                 }
[01:29:13.506]                 NAMES <- toupper(removed)
[01:29:13.506]                 for (kk in seq_along(NAMES)) {
[01:29:13.506]                   name <- removed[[kk]]
[01:29:13.506]                   NAME <- NAMES[[kk]]
[01:29:13.506]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.506]                     next
[01:29:13.506]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:13.506]                 }
[01:29:13.506]                 if (length(args) > 0) 
[01:29:13.506]                   base::do.call(base::Sys.setenv, args = args)
[01:29:13.506]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:13.506]             }
[01:29:13.506]             else {
[01:29:13.506]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:13.506]             }
[01:29:13.506]             {
[01:29:13.506]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:13.506]                   0L) {
[01:29:13.506]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:13.506]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:13.506]                   base::options(opts)
[01:29:13.506]                 }
[01:29:13.506]                 {
[01:29:13.506]                   {
[01:29:13.506]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:13.506]                     NULL
[01:29:13.506]                   }
[01:29:13.506]                   options(future.plan = NULL)
[01:29:13.506]                   if (is.na(NA_character_)) 
[01:29:13.506]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:13.506]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:13.506]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:13.506]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:13.506]                     envir = parent.frame()) 
[01:29:13.506]                   {
[01:29:13.506]                     if (is.function(workers)) 
[01:29:13.506]                       workers <- workers()
[01:29:13.506]                     workers <- structure(as.integer(workers), 
[01:29:13.506]                       class = class(workers))
[01:29:13.506]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:13.506]                       workers >= 1)
[01:29:13.506]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:13.506]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:13.506]                     }
[01:29:13.506]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:13.506]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:13.506]                       envir = envir)
[01:29:13.506]                     if (!future$lazy) 
[01:29:13.506]                       future <- run(future)
[01:29:13.506]                     invisible(future)
[01:29:13.506]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:13.506]                 }
[01:29:13.506]             }
[01:29:13.506]         }
[01:29:13.506]     })
[01:29:13.506]     if (TRUE) {
[01:29:13.506]         base::sink(type = "output", split = FALSE)
[01:29:13.506]         if (TRUE) {
[01:29:13.506]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:13.506]         }
[01:29:13.506]         else {
[01:29:13.506]             ...future.result["stdout"] <- base::list(NULL)
[01:29:13.506]         }
[01:29:13.506]         base::close(...future.stdout)
[01:29:13.506]         ...future.stdout <- NULL
[01:29:13.506]     }
[01:29:13.506]     ...future.result$conditions <- ...future.conditions
[01:29:13.506]     ...future.result$finished <- base::Sys.time()
[01:29:13.506]     ...future.result
[01:29:13.506] }
[01:29:13.512] MultisessionFuture started
[01:29:13.512] - Launch lazy future ... done
[01:29:13.513] run() for 'MultisessionFuture' ... done
[01:29:13.513] getGlobalsAndPackages() ...
[01:29:13.513] Searching for globals...
[01:29:13.514] - globals found: [1] '{'
[01:29:13.514] Searching for globals ... DONE
[01:29:13.514] Resolving globals: FALSE
[01:29:13.515] 
[01:29:13.515] 
[01:29:13.515] getGlobalsAndPackages() ... DONE
[01:29:13.515] run() for 'Future' ...
[01:29:13.516] - state: 'created'
[01:29:13.516] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:13.531] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:13.531] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:13.531]   - Field: 'node'
[01:29:13.532]   - Field: 'label'
[01:29:13.532]   - Field: 'local'
[01:29:13.532]   - Field: 'owner'
[01:29:13.532]   - Field: 'envir'
[01:29:13.532]   - Field: 'workers'
[01:29:13.533]   - Field: 'packages'
[01:29:13.533]   - Field: 'gc'
[01:29:13.533]   - Field: 'conditions'
[01:29:13.533]   - Field: 'persistent'
[01:29:13.533]   - Field: 'expr'
[01:29:13.533]   - Field: 'uuid'
[01:29:13.534]   - Field: 'seed'
[01:29:13.534]   - Field: 'version'
[01:29:13.534]   - Field: 'result'
[01:29:13.534]   - Field: 'asynchronous'
[01:29:13.534]   - Field: 'calls'
[01:29:13.535]   - Field: 'globals'
[01:29:13.535]   - Field: 'stdout'
[01:29:13.535]   - Field: 'earlySignal'
[01:29:13.535]   - Field: 'lazy'
[01:29:13.535]   - Field: 'state'
[01:29:13.535] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:13.539] - Launch lazy future ...
[01:29:13.540] Packages needed by the future expression (n = 0): <none>
[01:29:13.540] Packages needed by future strategies (n = 0): <none>
[01:29:13.541] {
[01:29:13.541]     {
[01:29:13.541]         {
[01:29:13.541]             ...future.startTime <- base::Sys.time()
[01:29:13.541]             {
[01:29:13.541]                 {
[01:29:13.541]                   {
[01:29:13.541]                     {
[01:29:13.541]                       base::local({
[01:29:13.541]                         has_future <- base::requireNamespace("future", 
[01:29:13.541]                           quietly = TRUE)
[01:29:13.541]                         if (has_future) {
[01:29:13.541]                           ns <- base::getNamespace("future")
[01:29:13.541]                           version <- ns[[".package"]][["version"]]
[01:29:13.541]                           if (is.null(version)) 
[01:29:13.541]                             version <- utils::packageVersion("future")
[01:29:13.541]                         }
[01:29:13.541]                         else {
[01:29:13.541]                           version <- NULL
[01:29:13.541]                         }
[01:29:13.541]                         if (!has_future || version < "1.8.0") {
[01:29:13.541]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:13.541]                             "", base::R.version$version.string), 
[01:29:13.541]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:13.541]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:13.541]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:13.541]                               "release", "version")], collapse = " "), 
[01:29:13.541]                             hostname = base::Sys.info()[["nodename"]])
[01:29:13.541]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:13.541]                             info)
[01:29:13.541]                           info <- base::paste(info, collapse = "; ")
[01:29:13.541]                           if (!has_future) {
[01:29:13.541]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:13.541]                               info)
[01:29:13.541]                           }
[01:29:13.541]                           else {
[01:29:13.541]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:13.541]                               info, version)
[01:29:13.541]                           }
[01:29:13.541]                           base::stop(msg)
[01:29:13.541]                         }
[01:29:13.541]                       })
[01:29:13.541]                     }
[01:29:13.541]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:13.541]                     base::options(mc.cores = 1L)
[01:29:13.541]                   }
[01:29:13.541]                   options(future.plan = NULL)
[01:29:13.541]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:13.541]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:13.541]                 }
[01:29:13.541]                 ...future.workdir <- getwd()
[01:29:13.541]             }
[01:29:13.541]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:13.541]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:13.541]         }
[01:29:13.541]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:13.541]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:13.541]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:13.541]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:13.541]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:13.541]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:13.541]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:13.541]             base::names(...future.oldOptions))
[01:29:13.541]     }
[01:29:13.541]     if (FALSE) {
[01:29:13.541]     }
[01:29:13.541]     else {
[01:29:13.541]         if (TRUE) {
[01:29:13.541]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:13.541]                 open = "w")
[01:29:13.541]         }
[01:29:13.541]         else {
[01:29:13.541]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:13.541]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:13.541]         }
[01:29:13.541]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:13.541]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:13.541]             base::sink(type = "output", split = FALSE)
[01:29:13.541]             base::close(...future.stdout)
[01:29:13.541]         }, add = TRUE)
[01:29:13.541]     }
[01:29:13.541]     ...future.frame <- base::sys.nframe()
[01:29:13.541]     ...future.conditions <- base::list()
[01:29:13.541]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:13.541]     if (FALSE) {
[01:29:13.541]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:13.541]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:13.541]     }
[01:29:13.541]     ...future.result <- base::tryCatch({
[01:29:13.541]         base::withCallingHandlers({
[01:29:13.541]             ...future.value <- base::withVisible(base::local({
[01:29:13.541]                 ...future.makeSendCondition <- base::local({
[01:29:13.541]                   sendCondition <- NULL
[01:29:13.541]                   function(frame = 1L) {
[01:29:13.541]                     if (is.function(sendCondition)) 
[01:29:13.541]                       return(sendCondition)
[01:29:13.541]                     ns <- getNamespace("parallel")
[01:29:13.541]                     if (exists("sendData", mode = "function", 
[01:29:13.541]                       envir = ns)) {
[01:29:13.541]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:13.541]                         envir = ns)
[01:29:13.541]                       envir <- sys.frame(frame)
[01:29:13.541]                       master <- NULL
[01:29:13.541]                       while (!identical(envir, .GlobalEnv) && 
[01:29:13.541]                         !identical(envir, emptyenv())) {
[01:29:13.541]                         if (exists("master", mode = "list", envir = envir, 
[01:29:13.541]                           inherits = FALSE)) {
[01:29:13.541]                           master <- get("master", mode = "list", 
[01:29:13.541]                             envir = envir, inherits = FALSE)
[01:29:13.541]                           if (inherits(master, c("SOCKnode", 
[01:29:13.541]                             "SOCK0node"))) {
[01:29:13.541]                             sendCondition <<- function(cond) {
[01:29:13.541]                               data <- list(type = "VALUE", value = cond, 
[01:29:13.541]                                 success = TRUE)
[01:29:13.541]                               parallel_sendData(master, data)
[01:29:13.541]                             }
[01:29:13.541]                             return(sendCondition)
[01:29:13.541]                           }
[01:29:13.541]                         }
[01:29:13.541]                         frame <- frame + 1L
[01:29:13.541]                         envir <- sys.frame(frame)
[01:29:13.541]                       }
[01:29:13.541]                     }
[01:29:13.541]                     sendCondition <<- function(cond) NULL
[01:29:13.541]                   }
[01:29:13.541]                 })
[01:29:13.541]                 withCallingHandlers({
[01:29:13.541]                   {
[01:29:13.541]                     2
[01:29:13.541]                   }
[01:29:13.541]                 }, immediateCondition = function(cond) {
[01:29:13.541]                   sendCondition <- ...future.makeSendCondition()
[01:29:13.541]                   sendCondition(cond)
[01:29:13.541]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.541]                   {
[01:29:13.541]                     inherits <- base::inherits
[01:29:13.541]                     invokeRestart <- base::invokeRestart
[01:29:13.541]                     is.null <- base::is.null
[01:29:13.541]                     muffled <- FALSE
[01:29:13.541]                     if (inherits(cond, "message")) {
[01:29:13.541]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:13.541]                       if (muffled) 
[01:29:13.541]                         invokeRestart("muffleMessage")
[01:29:13.541]                     }
[01:29:13.541]                     else if (inherits(cond, "warning")) {
[01:29:13.541]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:13.541]                       if (muffled) 
[01:29:13.541]                         invokeRestart("muffleWarning")
[01:29:13.541]                     }
[01:29:13.541]                     else if (inherits(cond, "condition")) {
[01:29:13.541]                       if (!is.null(pattern)) {
[01:29:13.541]                         computeRestarts <- base::computeRestarts
[01:29:13.541]                         grepl <- base::grepl
[01:29:13.541]                         restarts <- computeRestarts(cond)
[01:29:13.541]                         for (restart in restarts) {
[01:29:13.541]                           name <- restart$name
[01:29:13.541]                           if (is.null(name)) 
[01:29:13.541]                             next
[01:29:13.541]                           if (!grepl(pattern, name)) 
[01:29:13.541]                             next
[01:29:13.541]                           invokeRestart(restart)
[01:29:13.541]                           muffled <- TRUE
[01:29:13.541]                           break
[01:29:13.541]                         }
[01:29:13.541]                       }
[01:29:13.541]                     }
[01:29:13.541]                     invisible(muffled)
[01:29:13.541]                   }
[01:29:13.541]                   muffleCondition(cond)
[01:29:13.541]                 })
[01:29:13.541]             }))
[01:29:13.541]             future::FutureResult(value = ...future.value$value, 
[01:29:13.541]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:13.541]                   ...future.rng), globalenv = if (FALSE) 
[01:29:13.541]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:13.541]                     ...future.globalenv.names))
[01:29:13.541]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:13.541]         }, condition = base::local({
[01:29:13.541]             c <- base::c
[01:29:13.541]             inherits <- base::inherits
[01:29:13.541]             invokeRestart <- base::invokeRestart
[01:29:13.541]             length <- base::length
[01:29:13.541]             list <- base::list
[01:29:13.541]             seq.int <- base::seq.int
[01:29:13.541]             signalCondition <- base::signalCondition
[01:29:13.541]             sys.calls <- base::sys.calls
[01:29:13.541]             `[[` <- base::`[[`
[01:29:13.541]             `+` <- base::`+`
[01:29:13.541]             `<<-` <- base::`<<-`
[01:29:13.541]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:13.541]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:13.541]                   3L)]
[01:29:13.541]             }
[01:29:13.541]             function(cond) {
[01:29:13.541]                 is_error <- inherits(cond, "error")
[01:29:13.541]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:13.541]                   NULL)
[01:29:13.541]                 if (is_error) {
[01:29:13.541]                   sessionInformation <- function() {
[01:29:13.541]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:13.541]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:13.541]                       search = base::search(), system = base::Sys.info())
[01:29:13.541]                   }
[01:29:13.541]                   ...future.conditions[[length(...future.conditions) + 
[01:29:13.541]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:13.541]                     cond$call), session = sessionInformation(), 
[01:29:13.541]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:13.541]                   signalCondition(cond)
[01:29:13.541]                 }
[01:29:13.541]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:13.541]                 "immediateCondition"))) {
[01:29:13.541]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:13.541]                   ...future.conditions[[length(...future.conditions) + 
[01:29:13.541]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:13.541]                   if (TRUE && !signal) {
[01:29:13.541]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.541]                     {
[01:29:13.541]                       inherits <- base::inherits
[01:29:13.541]                       invokeRestart <- base::invokeRestart
[01:29:13.541]                       is.null <- base::is.null
[01:29:13.541]                       muffled <- FALSE
[01:29:13.541]                       if (inherits(cond, "message")) {
[01:29:13.541]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:13.541]                         if (muffled) 
[01:29:13.541]                           invokeRestart("muffleMessage")
[01:29:13.541]                       }
[01:29:13.541]                       else if (inherits(cond, "warning")) {
[01:29:13.541]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:13.541]                         if (muffled) 
[01:29:13.541]                           invokeRestart("muffleWarning")
[01:29:13.541]                       }
[01:29:13.541]                       else if (inherits(cond, "condition")) {
[01:29:13.541]                         if (!is.null(pattern)) {
[01:29:13.541]                           computeRestarts <- base::computeRestarts
[01:29:13.541]                           grepl <- base::grepl
[01:29:13.541]                           restarts <- computeRestarts(cond)
[01:29:13.541]                           for (restart in restarts) {
[01:29:13.541]                             name <- restart$name
[01:29:13.541]                             if (is.null(name)) 
[01:29:13.541]                               next
[01:29:13.541]                             if (!grepl(pattern, name)) 
[01:29:13.541]                               next
[01:29:13.541]                             invokeRestart(restart)
[01:29:13.541]                             muffled <- TRUE
[01:29:13.541]                             break
[01:29:13.541]                           }
[01:29:13.541]                         }
[01:29:13.541]                       }
[01:29:13.541]                       invisible(muffled)
[01:29:13.541]                     }
[01:29:13.541]                     muffleCondition(cond, pattern = "^muffle")
[01:29:13.541]                   }
[01:29:13.541]                 }
[01:29:13.541]                 else {
[01:29:13.541]                   if (TRUE) {
[01:29:13.541]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.541]                     {
[01:29:13.541]                       inherits <- base::inherits
[01:29:13.541]                       invokeRestart <- base::invokeRestart
[01:29:13.541]                       is.null <- base::is.null
[01:29:13.541]                       muffled <- FALSE
[01:29:13.541]                       if (inherits(cond, "message")) {
[01:29:13.541]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:13.541]                         if (muffled) 
[01:29:13.541]                           invokeRestart("muffleMessage")
[01:29:13.541]                       }
[01:29:13.541]                       else if (inherits(cond, "warning")) {
[01:29:13.541]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:13.541]                         if (muffled) 
[01:29:13.541]                           invokeRestart("muffleWarning")
[01:29:13.541]                       }
[01:29:13.541]                       else if (inherits(cond, "condition")) {
[01:29:13.541]                         if (!is.null(pattern)) {
[01:29:13.541]                           computeRestarts <- base::computeRestarts
[01:29:13.541]                           grepl <- base::grepl
[01:29:13.541]                           restarts <- computeRestarts(cond)
[01:29:13.541]                           for (restart in restarts) {
[01:29:13.541]                             name <- restart$name
[01:29:13.541]                             if (is.null(name)) 
[01:29:13.541]                               next
[01:29:13.541]                             if (!grepl(pattern, name)) 
[01:29:13.541]                               next
[01:29:13.541]                             invokeRestart(restart)
[01:29:13.541]                             muffled <- TRUE
[01:29:13.541]                             break
[01:29:13.541]                           }
[01:29:13.541]                         }
[01:29:13.541]                       }
[01:29:13.541]                       invisible(muffled)
[01:29:13.541]                     }
[01:29:13.541]                     muffleCondition(cond, pattern = "^muffle")
[01:29:13.541]                   }
[01:29:13.541]                 }
[01:29:13.541]             }
[01:29:13.541]         }))
[01:29:13.541]     }, error = function(ex) {
[01:29:13.541]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:13.541]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:13.541]                 ...future.rng), started = ...future.startTime, 
[01:29:13.541]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:13.541]             version = "1.8"), class = "FutureResult")
[01:29:13.541]     }, finally = {
[01:29:13.541]         if (!identical(...future.workdir, getwd())) 
[01:29:13.541]             setwd(...future.workdir)
[01:29:13.541]         {
[01:29:13.541]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:13.541]                 ...future.oldOptions$nwarnings <- NULL
[01:29:13.541]             }
[01:29:13.541]             base::options(...future.oldOptions)
[01:29:13.541]             if (.Platform$OS.type == "windows") {
[01:29:13.541]                 old_names <- names(...future.oldEnvVars)
[01:29:13.541]                 envs <- base::Sys.getenv()
[01:29:13.541]                 names <- names(envs)
[01:29:13.541]                 common <- intersect(names, old_names)
[01:29:13.541]                 added <- setdiff(names, old_names)
[01:29:13.541]                 removed <- setdiff(old_names, names)
[01:29:13.541]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:13.541]                   envs[common]]
[01:29:13.541]                 NAMES <- toupper(changed)
[01:29:13.541]                 args <- list()
[01:29:13.541]                 for (kk in seq_along(NAMES)) {
[01:29:13.541]                   name <- changed[[kk]]
[01:29:13.541]                   NAME <- NAMES[[kk]]
[01:29:13.541]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.541]                     next
[01:29:13.541]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:13.541]                 }
[01:29:13.541]                 NAMES <- toupper(added)
[01:29:13.541]                 for (kk in seq_along(NAMES)) {
[01:29:13.541]                   name <- added[[kk]]
[01:29:13.541]                   NAME <- NAMES[[kk]]
[01:29:13.541]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.541]                     next
[01:29:13.541]                   args[[name]] <- ""
[01:29:13.541]                 }
[01:29:13.541]                 NAMES <- toupper(removed)
[01:29:13.541]                 for (kk in seq_along(NAMES)) {
[01:29:13.541]                   name <- removed[[kk]]
[01:29:13.541]                   NAME <- NAMES[[kk]]
[01:29:13.541]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.541]                     next
[01:29:13.541]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:13.541]                 }
[01:29:13.541]                 if (length(args) > 0) 
[01:29:13.541]                   base::do.call(base::Sys.setenv, args = args)
[01:29:13.541]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:13.541]             }
[01:29:13.541]             else {
[01:29:13.541]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:13.541]             }
[01:29:13.541]             {
[01:29:13.541]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:13.541]                   0L) {
[01:29:13.541]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:13.541]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:13.541]                   base::options(opts)
[01:29:13.541]                 }
[01:29:13.541]                 {
[01:29:13.541]                   {
[01:29:13.541]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:13.541]                     NULL
[01:29:13.541]                   }
[01:29:13.541]                   options(future.plan = NULL)
[01:29:13.541]                   if (is.na(NA_character_)) 
[01:29:13.541]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:13.541]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:13.541]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:13.541]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:13.541]                     envir = parent.frame()) 
[01:29:13.541]                   {
[01:29:13.541]                     if (is.function(workers)) 
[01:29:13.541]                       workers <- workers()
[01:29:13.541]                     workers <- structure(as.integer(workers), 
[01:29:13.541]                       class = class(workers))
[01:29:13.541]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:13.541]                       workers >= 1)
[01:29:13.541]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:13.541]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:13.541]                     }
[01:29:13.541]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:13.541]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:13.541]                       envir = envir)
[01:29:13.541]                     if (!future$lazy) 
[01:29:13.541]                       future <- run(future)
[01:29:13.541]                     invisible(future)
[01:29:13.541]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:13.541]                 }
[01:29:13.541]             }
[01:29:13.541]         }
[01:29:13.541]     })
[01:29:13.541]     if (TRUE) {
[01:29:13.541]         base::sink(type = "output", split = FALSE)
[01:29:13.541]         if (TRUE) {
[01:29:13.541]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:13.541]         }
[01:29:13.541]         else {
[01:29:13.541]             ...future.result["stdout"] <- base::list(NULL)
[01:29:13.541]         }
[01:29:13.541]         base::close(...future.stdout)
[01:29:13.541]         ...future.stdout <- NULL
[01:29:13.541]     }
[01:29:13.541]     ...future.result$conditions <- ...future.conditions
[01:29:13.541]     ...future.result$finished <- base::Sys.time()
[01:29:13.541]     ...future.result
[01:29:13.541] }
[01:29:13.546] MultisessionFuture started
[01:29:13.547] - Launch lazy future ... done
[01:29:13.547] run() for 'MultisessionFuture' ... done
[01:29:13.548] resolve() on environment ...
[01:29:13.548]  recursive: 0
[01:29:13.548]  elements: [3] '.future_a', '.future_b', 'a', 'b', 'c'
[01:29:13.549] receiveMessageFromWorker() for ClusterFuture ...
[01:29:13.549] - Validating connection of MultisessionFuture
[01:29:13.549] - received message: FutureResult
[01:29:13.550] - Received FutureResult
[01:29:13.550] - Erased future from FutureRegistry
[01:29:13.550] result() for ClusterFuture ...
[01:29:13.550] - result already collected: FutureResult
[01:29:13.550] result() for ClusterFuture ... done
[01:29:13.550] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:13.550] Future #1
[01:29:13.551]  length: 2 (resolved future 1)
[01:29:13.565] receiveMessageFromWorker() for ClusterFuture ...
[01:29:13.566] - Validating connection of MultisessionFuture
[01:29:13.566] - received message: FutureResult
[01:29:13.566] - Received FutureResult
[01:29:13.566] - Erased future from FutureRegistry
[01:29:13.566] result() for ClusterFuture ...
[01:29:13.567] - result already collected: FutureResult
[01:29:13.567] result() for ClusterFuture ... done
[01:29:13.567] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:13.567] Future #2
[01:29:13.567]  length: 1 (resolved future 2)
[01:29:13.567]  length: 0 (resolved future 3)
[01:29:13.568] resolve() on environment ... DONE
[01:29:13.568] getGlobalsAndPackages() ...
[01:29:13.568] Searching for globals...
[01:29:13.569] - globals found: [1] '{'
[01:29:13.569] Searching for globals ... DONE
[01:29:13.570] Resolving globals: FALSE
[01:29:13.570] 
[01:29:13.570] 
[01:29:13.570] getGlobalsAndPackages() ... DONE
[01:29:13.571] run() for 'Future' ...
[01:29:13.571] - state: 'created'
[01:29:13.571] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:13.585] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:13.586] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:13.586]   - Field: 'node'
[01:29:13.586]   - Field: 'label'
[01:29:13.586]   - Field: 'local'
[01:29:13.586]   - Field: 'owner'
[01:29:13.587]   - Field: 'envir'
[01:29:13.587]   - Field: 'workers'
[01:29:13.587]   - Field: 'packages'
[01:29:13.587]   - Field: 'gc'
[01:29:13.587]   - Field: 'conditions'
[01:29:13.588]   - Field: 'persistent'
[01:29:13.588]   - Field: 'expr'
[01:29:13.588]   - Field: 'uuid'
[01:29:13.588]   - Field: 'seed'
[01:29:13.588]   - Field: 'version'
[01:29:13.588]   - Field: 'result'
[01:29:13.589]   - Field: 'asynchronous'
[01:29:13.589]   - Field: 'calls'
[01:29:13.589]   - Field: 'globals'
[01:29:13.589]   - Field: 'stdout'
[01:29:13.589]   - Field: 'earlySignal'
[01:29:13.589]   - Field: 'lazy'
[01:29:13.590]   - Field: 'state'
[01:29:13.590] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:13.590] - Launch lazy future ...
[01:29:13.590] Packages needed by the future expression (n = 0): <none>
[01:29:13.591] Packages needed by future strategies (n = 0): <none>
[01:29:13.591] {
[01:29:13.591]     {
[01:29:13.591]         {
[01:29:13.591]             ...future.startTime <- base::Sys.time()
[01:29:13.591]             {
[01:29:13.591]                 {
[01:29:13.591]                   {
[01:29:13.591]                     {
[01:29:13.591]                       base::local({
[01:29:13.591]                         has_future <- base::requireNamespace("future", 
[01:29:13.591]                           quietly = TRUE)
[01:29:13.591]                         if (has_future) {
[01:29:13.591]                           ns <- base::getNamespace("future")
[01:29:13.591]                           version <- ns[[".package"]][["version"]]
[01:29:13.591]                           if (is.null(version)) 
[01:29:13.591]                             version <- utils::packageVersion("future")
[01:29:13.591]                         }
[01:29:13.591]                         else {
[01:29:13.591]                           version <- NULL
[01:29:13.591]                         }
[01:29:13.591]                         if (!has_future || version < "1.8.0") {
[01:29:13.591]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:13.591]                             "", base::R.version$version.string), 
[01:29:13.591]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:13.591]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:13.591]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:13.591]                               "release", "version")], collapse = " "), 
[01:29:13.591]                             hostname = base::Sys.info()[["nodename"]])
[01:29:13.591]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:13.591]                             info)
[01:29:13.591]                           info <- base::paste(info, collapse = "; ")
[01:29:13.591]                           if (!has_future) {
[01:29:13.591]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:13.591]                               info)
[01:29:13.591]                           }
[01:29:13.591]                           else {
[01:29:13.591]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:13.591]                               info, version)
[01:29:13.591]                           }
[01:29:13.591]                           base::stop(msg)
[01:29:13.591]                         }
[01:29:13.591]                       })
[01:29:13.591]                     }
[01:29:13.591]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:13.591]                     base::options(mc.cores = 1L)
[01:29:13.591]                   }
[01:29:13.591]                   options(future.plan = NULL)
[01:29:13.591]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:13.591]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:13.591]                 }
[01:29:13.591]                 ...future.workdir <- getwd()
[01:29:13.591]             }
[01:29:13.591]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:13.591]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:13.591]         }
[01:29:13.591]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:13.591]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:13.591]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:13.591]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:13.591]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:13.591]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:13.591]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:13.591]             base::names(...future.oldOptions))
[01:29:13.591]     }
[01:29:13.591]     if (FALSE) {
[01:29:13.591]     }
[01:29:13.591]     else {
[01:29:13.591]         if (TRUE) {
[01:29:13.591]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:13.591]                 open = "w")
[01:29:13.591]         }
[01:29:13.591]         else {
[01:29:13.591]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:13.591]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:13.591]         }
[01:29:13.591]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:13.591]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:13.591]             base::sink(type = "output", split = FALSE)
[01:29:13.591]             base::close(...future.stdout)
[01:29:13.591]         }, add = TRUE)
[01:29:13.591]     }
[01:29:13.591]     ...future.frame <- base::sys.nframe()
[01:29:13.591]     ...future.conditions <- base::list()
[01:29:13.591]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:13.591]     if (FALSE) {
[01:29:13.591]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:13.591]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:13.591]     }
[01:29:13.591]     ...future.result <- base::tryCatch({
[01:29:13.591]         base::withCallingHandlers({
[01:29:13.591]             ...future.value <- base::withVisible(base::local({
[01:29:13.591]                 ...future.makeSendCondition <- base::local({
[01:29:13.591]                   sendCondition <- NULL
[01:29:13.591]                   function(frame = 1L) {
[01:29:13.591]                     if (is.function(sendCondition)) 
[01:29:13.591]                       return(sendCondition)
[01:29:13.591]                     ns <- getNamespace("parallel")
[01:29:13.591]                     if (exists("sendData", mode = "function", 
[01:29:13.591]                       envir = ns)) {
[01:29:13.591]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:13.591]                         envir = ns)
[01:29:13.591]                       envir <- sys.frame(frame)
[01:29:13.591]                       master <- NULL
[01:29:13.591]                       while (!identical(envir, .GlobalEnv) && 
[01:29:13.591]                         !identical(envir, emptyenv())) {
[01:29:13.591]                         if (exists("master", mode = "list", envir = envir, 
[01:29:13.591]                           inherits = FALSE)) {
[01:29:13.591]                           master <- get("master", mode = "list", 
[01:29:13.591]                             envir = envir, inherits = FALSE)
[01:29:13.591]                           if (inherits(master, c("SOCKnode", 
[01:29:13.591]                             "SOCK0node"))) {
[01:29:13.591]                             sendCondition <<- function(cond) {
[01:29:13.591]                               data <- list(type = "VALUE", value = cond, 
[01:29:13.591]                                 success = TRUE)
[01:29:13.591]                               parallel_sendData(master, data)
[01:29:13.591]                             }
[01:29:13.591]                             return(sendCondition)
[01:29:13.591]                           }
[01:29:13.591]                         }
[01:29:13.591]                         frame <- frame + 1L
[01:29:13.591]                         envir <- sys.frame(frame)
[01:29:13.591]                       }
[01:29:13.591]                     }
[01:29:13.591]                     sendCondition <<- function(cond) NULL
[01:29:13.591]                   }
[01:29:13.591]                 })
[01:29:13.591]                 withCallingHandlers({
[01:29:13.591]                   {
[01:29:13.591]                     1
[01:29:13.591]                   }
[01:29:13.591]                 }, immediateCondition = function(cond) {
[01:29:13.591]                   sendCondition <- ...future.makeSendCondition()
[01:29:13.591]                   sendCondition(cond)
[01:29:13.591]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.591]                   {
[01:29:13.591]                     inherits <- base::inherits
[01:29:13.591]                     invokeRestart <- base::invokeRestart
[01:29:13.591]                     is.null <- base::is.null
[01:29:13.591]                     muffled <- FALSE
[01:29:13.591]                     if (inherits(cond, "message")) {
[01:29:13.591]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:13.591]                       if (muffled) 
[01:29:13.591]                         invokeRestart("muffleMessage")
[01:29:13.591]                     }
[01:29:13.591]                     else if (inherits(cond, "warning")) {
[01:29:13.591]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:13.591]                       if (muffled) 
[01:29:13.591]                         invokeRestart("muffleWarning")
[01:29:13.591]                     }
[01:29:13.591]                     else if (inherits(cond, "condition")) {
[01:29:13.591]                       if (!is.null(pattern)) {
[01:29:13.591]                         computeRestarts <- base::computeRestarts
[01:29:13.591]                         grepl <- base::grepl
[01:29:13.591]                         restarts <- computeRestarts(cond)
[01:29:13.591]                         for (restart in restarts) {
[01:29:13.591]                           name <- restart$name
[01:29:13.591]                           if (is.null(name)) 
[01:29:13.591]                             next
[01:29:13.591]                           if (!grepl(pattern, name)) 
[01:29:13.591]                             next
[01:29:13.591]                           invokeRestart(restart)
[01:29:13.591]                           muffled <- TRUE
[01:29:13.591]                           break
[01:29:13.591]                         }
[01:29:13.591]                       }
[01:29:13.591]                     }
[01:29:13.591]                     invisible(muffled)
[01:29:13.591]                   }
[01:29:13.591]                   muffleCondition(cond)
[01:29:13.591]                 })
[01:29:13.591]             }))
[01:29:13.591]             future::FutureResult(value = ...future.value$value, 
[01:29:13.591]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:13.591]                   ...future.rng), globalenv = if (FALSE) 
[01:29:13.591]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:13.591]                     ...future.globalenv.names))
[01:29:13.591]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:13.591]         }, condition = base::local({
[01:29:13.591]             c <- base::c
[01:29:13.591]             inherits <- base::inherits
[01:29:13.591]             invokeRestart <- base::invokeRestart
[01:29:13.591]             length <- base::length
[01:29:13.591]             list <- base::list
[01:29:13.591]             seq.int <- base::seq.int
[01:29:13.591]             signalCondition <- base::signalCondition
[01:29:13.591]             sys.calls <- base::sys.calls
[01:29:13.591]             `[[` <- base::`[[`
[01:29:13.591]             `+` <- base::`+`
[01:29:13.591]             `<<-` <- base::`<<-`
[01:29:13.591]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:13.591]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:13.591]                   3L)]
[01:29:13.591]             }
[01:29:13.591]             function(cond) {
[01:29:13.591]                 is_error <- inherits(cond, "error")
[01:29:13.591]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:13.591]                   NULL)
[01:29:13.591]                 if (is_error) {
[01:29:13.591]                   sessionInformation <- function() {
[01:29:13.591]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:13.591]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:13.591]                       search = base::search(), system = base::Sys.info())
[01:29:13.591]                   }
[01:29:13.591]                   ...future.conditions[[length(...future.conditions) + 
[01:29:13.591]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:13.591]                     cond$call), session = sessionInformation(), 
[01:29:13.591]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:13.591]                   signalCondition(cond)
[01:29:13.591]                 }
[01:29:13.591]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:13.591]                 "immediateCondition"))) {
[01:29:13.591]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:13.591]                   ...future.conditions[[length(...future.conditions) + 
[01:29:13.591]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:13.591]                   if (TRUE && !signal) {
[01:29:13.591]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.591]                     {
[01:29:13.591]                       inherits <- base::inherits
[01:29:13.591]                       invokeRestart <- base::invokeRestart
[01:29:13.591]                       is.null <- base::is.null
[01:29:13.591]                       muffled <- FALSE
[01:29:13.591]                       if (inherits(cond, "message")) {
[01:29:13.591]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:13.591]                         if (muffled) 
[01:29:13.591]                           invokeRestart("muffleMessage")
[01:29:13.591]                       }
[01:29:13.591]                       else if (inherits(cond, "warning")) {
[01:29:13.591]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:13.591]                         if (muffled) 
[01:29:13.591]                           invokeRestart("muffleWarning")
[01:29:13.591]                       }
[01:29:13.591]                       else if (inherits(cond, "condition")) {
[01:29:13.591]                         if (!is.null(pattern)) {
[01:29:13.591]                           computeRestarts <- base::computeRestarts
[01:29:13.591]                           grepl <- base::grepl
[01:29:13.591]                           restarts <- computeRestarts(cond)
[01:29:13.591]                           for (restart in restarts) {
[01:29:13.591]                             name <- restart$name
[01:29:13.591]                             if (is.null(name)) 
[01:29:13.591]                               next
[01:29:13.591]                             if (!grepl(pattern, name)) 
[01:29:13.591]                               next
[01:29:13.591]                             invokeRestart(restart)
[01:29:13.591]                             muffled <- TRUE
[01:29:13.591]                             break
[01:29:13.591]                           }
[01:29:13.591]                         }
[01:29:13.591]                       }
[01:29:13.591]                       invisible(muffled)
[01:29:13.591]                     }
[01:29:13.591]                     muffleCondition(cond, pattern = "^muffle")
[01:29:13.591]                   }
[01:29:13.591]                 }
[01:29:13.591]                 else {
[01:29:13.591]                   if (TRUE) {
[01:29:13.591]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.591]                     {
[01:29:13.591]                       inherits <- base::inherits
[01:29:13.591]                       invokeRestart <- base::invokeRestart
[01:29:13.591]                       is.null <- base::is.null
[01:29:13.591]                       muffled <- FALSE
[01:29:13.591]                       if (inherits(cond, "message")) {
[01:29:13.591]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:13.591]                         if (muffled) 
[01:29:13.591]                           invokeRestart("muffleMessage")
[01:29:13.591]                       }
[01:29:13.591]                       else if (inherits(cond, "warning")) {
[01:29:13.591]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:13.591]                         if (muffled) 
[01:29:13.591]                           invokeRestart("muffleWarning")
[01:29:13.591]                       }
[01:29:13.591]                       else if (inherits(cond, "condition")) {
[01:29:13.591]                         if (!is.null(pattern)) {
[01:29:13.591]                           computeRestarts <- base::computeRestarts
[01:29:13.591]                           grepl <- base::grepl
[01:29:13.591]                           restarts <- computeRestarts(cond)
[01:29:13.591]                           for (restart in restarts) {
[01:29:13.591]                             name <- restart$name
[01:29:13.591]                             if (is.null(name)) 
[01:29:13.591]                               next
[01:29:13.591]                             if (!grepl(pattern, name)) 
[01:29:13.591]                               next
[01:29:13.591]                             invokeRestart(restart)
[01:29:13.591]                             muffled <- TRUE
[01:29:13.591]                             break
[01:29:13.591]                           }
[01:29:13.591]                         }
[01:29:13.591]                       }
[01:29:13.591]                       invisible(muffled)
[01:29:13.591]                     }
[01:29:13.591]                     muffleCondition(cond, pattern = "^muffle")
[01:29:13.591]                   }
[01:29:13.591]                 }
[01:29:13.591]             }
[01:29:13.591]         }))
[01:29:13.591]     }, error = function(ex) {
[01:29:13.591]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:13.591]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:13.591]                 ...future.rng), started = ...future.startTime, 
[01:29:13.591]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:13.591]             version = "1.8"), class = "FutureResult")
[01:29:13.591]     }, finally = {
[01:29:13.591]         if (!identical(...future.workdir, getwd())) 
[01:29:13.591]             setwd(...future.workdir)
[01:29:13.591]         {
[01:29:13.591]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:13.591]                 ...future.oldOptions$nwarnings <- NULL
[01:29:13.591]             }
[01:29:13.591]             base::options(...future.oldOptions)
[01:29:13.591]             if (.Platform$OS.type == "windows") {
[01:29:13.591]                 old_names <- names(...future.oldEnvVars)
[01:29:13.591]                 envs <- base::Sys.getenv()
[01:29:13.591]                 names <- names(envs)
[01:29:13.591]                 common <- intersect(names, old_names)
[01:29:13.591]                 added <- setdiff(names, old_names)
[01:29:13.591]                 removed <- setdiff(old_names, names)
[01:29:13.591]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:13.591]                   envs[common]]
[01:29:13.591]                 NAMES <- toupper(changed)
[01:29:13.591]                 args <- list()
[01:29:13.591]                 for (kk in seq_along(NAMES)) {
[01:29:13.591]                   name <- changed[[kk]]
[01:29:13.591]                   NAME <- NAMES[[kk]]
[01:29:13.591]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.591]                     next
[01:29:13.591]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:13.591]                 }
[01:29:13.591]                 NAMES <- toupper(added)
[01:29:13.591]                 for (kk in seq_along(NAMES)) {
[01:29:13.591]                   name <- added[[kk]]
[01:29:13.591]                   NAME <- NAMES[[kk]]
[01:29:13.591]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.591]                     next
[01:29:13.591]                   args[[name]] <- ""
[01:29:13.591]                 }
[01:29:13.591]                 NAMES <- toupper(removed)
[01:29:13.591]                 for (kk in seq_along(NAMES)) {
[01:29:13.591]                   name <- removed[[kk]]
[01:29:13.591]                   NAME <- NAMES[[kk]]
[01:29:13.591]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.591]                     next
[01:29:13.591]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:13.591]                 }
[01:29:13.591]                 if (length(args) > 0) 
[01:29:13.591]                   base::do.call(base::Sys.setenv, args = args)
[01:29:13.591]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:13.591]             }
[01:29:13.591]             else {
[01:29:13.591]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:13.591]             }
[01:29:13.591]             {
[01:29:13.591]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:13.591]                   0L) {
[01:29:13.591]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:13.591]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:13.591]                   base::options(opts)
[01:29:13.591]                 }
[01:29:13.591]                 {
[01:29:13.591]                   {
[01:29:13.591]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:13.591]                     NULL
[01:29:13.591]                   }
[01:29:13.591]                   options(future.plan = NULL)
[01:29:13.591]                   if (is.na(NA_character_)) 
[01:29:13.591]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:13.591]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:13.591]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:13.591]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:13.591]                     envir = parent.frame()) 
[01:29:13.591]                   {
[01:29:13.591]                     if (is.function(workers)) 
[01:29:13.591]                       workers <- workers()
[01:29:13.591]                     workers <- structure(as.integer(workers), 
[01:29:13.591]                       class = class(workers))
[01:29:13.591]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:13.591]                       workers >= 1)
[01:29:13.591]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:13.591]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:13.591]                     }
[01:29:13.591]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:13.591]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:13.591]                       envir = envir)
[01:29:13.591]                     if (!future$lazy) 
[01:29:13.591]                       future <- run(future)
[01:29:13.591]                     invisible(future)
[01:29:13.591]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:13.591]                 }
[01:29:13.591]             }
[01:29:13.591]         }
[01:29:13.591]     })
[01:29:13.591]     if (TRUE) {
[01:29:13.591]         base::sink(type = "output", split = FALSE)
[01:29:13.591]         if (TRUE) {
[01:29:13.591]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:13.591]         }
[01:29:13.591]         else {
[01:29:13.591]             ...future.result["stdout"] <- base::list(NULL)
[01:29:13.591]         }
[01:29:13.591]         base::close(...future.stdout)
[01:29:13.591]         ...future.stdout <- NULL
[01:29:13.591]     }
[01:29:13.591]     ...future.result$conditions <- ...future.conditions
[01:29:13.591]     ...future.result$finished <- base::Sys.time()
[01:29:13.591]     ...future.result
[01:29:13.591] }
[01:29:13.597] MultisessionFuture started
[01:29:13.597] - Launch lazy future ... done
[01:29:13.598] run() for 'MultisessionFuture' ... done
[01:29:13.598] getGlobalsAndPackages() ...
[01:29:13.598] Searching for globals...
[01:29:13.599] - globals found: [1] '{'
[01:29:13.599] Searching for globals ... DONE
[01:29:13.599] Resolving globals: FALSE
[01:29:13.600] 
[01:29:13.600] 
[01:29:13.600] getGlobalsAndPackages() ... DONE
[01:29:13.600] run() for 'Future' ...
[01:29:13.601] - state: 'created'
[01:29:13.601] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:13.616] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:13.616] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:13.616]   - Field: 'node'
[01:29:13.616]   - Field: 'label'
[01:29:13.617]   - Field: 'local'
[01:29:13.617]   - Field: 'owner'
[01:29:13.617]   - Field: 'envir'
[01:29:13.617]   - Field: 'workers'
[01:29:13.617]   - Field: 'packages'
[01:29:13.618]   - Field: 'gc'
[01:29:13.618]   - Field: 'conditions'
[01:29:13.618]   - Field: 'persistent'
[01:29:13.618]   - Field: 'expr'
[01:29:13.618]   - Field: 'uuid'
[01:29:13.619]   - Field: 'seed'
[01:29:13.619]   - Field: 'version'
[01:29:13.619]   - Field: 'result'
[01:29:13.619]   - Field: 'asynchronous'
[01:29:13.619]   - Field: 'calls'
[01:29:13.620]   - Field: 'globals'
[01:29:13.620]   - Field: 'stdout'
[01:29:13.620]   - Field: 'earlySignal'
[01:29:13.620]   - Field: 'lazy'
[01:29:13.620]   - Field: 'state'
[01:29:13.620] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:13.621] - Launch lazy future ...
[01:29:13.621] Packages needed by the future expression (n = 0): <none>
[01:29:13.621] Packages needed by future strategies (n = 0): <none>
[01:29:13.622] {
[01:29:13.622]     {
[01:29:13.622]         {
[01:29:13.622]             ...future.startTime <- base::Sys.time()
[01:29:13.622]             {
[01:29:13.622]                 {
[01:29:13.622]                   {
[01:29:13.622]                     {
[01:29:13.622]                       base::local({
[01:29:13.622]                         has_future <- base::requireNamespace("future", 
[01:29:13.622]                           quietly = TRUE)
[01:29:13.622]                         if (has_future) {
[01:29:13.622]                           ns <- base::getNamespace("future")
[01:29:13.622]                           version <- ns[[".package"]][["version"]]
[01:29:13.622]                           if (is.null(version)) 
[01:29:13.622]                             version <- utils::packageVersion("future")
[01:29:13.622]                         }
[01:29:13.622]                         else {
[01:29:13.622]                           version <- NULL
[01:29:13.622]                         }
[01:29:13.622]                         if (!has_future || version < "1.8.0") {
[01:29:13.622]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:13.622]                             "", base::R.version$version.string), 
[01:29:13.622]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:13.622]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:13.622]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:13.622]                               "release", "version")], collapse = " "), 
[01:29:13.622]                             hostname = base::Sys.info()[["nodename"]])
[01:29:13.622]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:13.622]                             info)
[01:29:13.622]                           info <- base::paste(info, collapse = "; ")
[01:29:13.622]                           if (!has_future) {
[01:29:13.622]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:13.622]                               info)
[01:29:13.622]                           }
[01:29:13.622]                           else {
[01:29:13.622]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:13.622]                               info, version)
[01:29:13.622]                           }
[01:29:13.622]                           base::stop(msg)
[01:29:13.622]                         }
[01:29:13.622]                       })
[01:29:13.622]                     }
[01:29:13.622]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:13.622]                     base::options(mc.cores = 1L)
[01:29:13.622]                   }
[01:29:13.622]                   options(future.plan = NULL)
[01:29:13.622]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:13.622]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:13.622]                 }
[01:29:13.622]                 ...future.workdir <- getwd()
[01:29:13.622]             }
[01:29:13.622]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:13.622]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:13.622]         }
[01:29:13.622]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:13.622]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:13.622]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:13.622]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:13.622]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:13.622]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:13.622]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:13.622]             base::names(...future.oldOptions))
[01:29:13.622]     }
[01:29:13.622]     if (FALSE) {
[01:29:13.622]     }
[01:29:13.622]     else {
[01:29:13.622]         if (TRUE) {
[01:29:13.622]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:13.622]                 open = "w")
[01:29:13.622]         }
[01:29:13.622]         else {
[01:29:13.622]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:13.622]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:13.622]         }
[01:29:13.622]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:13.622]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:13.622]             base::sink(type = "output", split = FALSE)
[01:29:13.622]             base::close(...future.stdout)
[01:29:13.622]         }, add = TRUE)
[01:29:13.622]     }
[01:29:13.622]     ...future.frame <- base::sys.nframe()
[01:29:13.622]     ...future.conditions <- base::list()
[01:29:13.622]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:13.622]     if (FALSE) {
[01:29:13.622]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:13.622]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:13.622]     }
[01:29:13.622]     ...future.result <- base::tryCatch({
[01:29:13.622]         base::withCallingHandlers({
[01:29:13.622]             ...future.value <- base::withVisible(base::local({
[01:29:13.622]                 ...future.makeSendCondition <- base::local({
[01:29:13.622]                   sendCondition <- NULL
[01:29:13.622]                   function(frame = 1L) {
[01:29:13.622]                     if (is.function(sendCondition)) 
[01:29:13.622]                       return(sendCondition)
[01:29:13.622]                     ns <- getNamespace("parallel")
[01:29:13.622]                     if (exists("sendData", mode = "function", 
[01:29:13.622]                       envir = ns)) {
[01:29:13.622]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:13.622]                         envir = ns)
[01:29:13.622]                       envir <- sys.frame(frame)
[01:29:13.622]                       master <- NULL
[01:29:13.622]                       while (!identical(envir, .GlobalEnv) && 
[01:29:13.622]                         !identical(envir, emptyenv())) {
[01:29:13.622]                         if (exists("master", mode = "list", envir = envir, 
[01:29:13.622]                           inherits = FALSE)) {
[01:29:13.622]                           master <- get("master", mode = "list", 
[01:29:13.622]                             envir = envir, inherits = FALSE)
[01:29:13.622]                           if (inherits(master, c("SOCKnode", 
[01:29:13.622]                             "SOCK0node"))) {
[01:29:13.622]                             sendCondition <<- function(cond) {
[01:29:13.622]                               data <- list(type = "VALUE", value = cond, 
[01:29:13.622]                                 success = TRUE)
[01:29:13.622]                               parallel_sendData(master, data)
[01:29:13.622]                             }
[01:29:13.622]                             return(sendCondition)
[01:29:13.622]                           }
[01:29:13.622]                         }
[01:29:13.622]                         frame <- frame + 1L
[01:29:13.622]                         envir <- sys.frame(frame)
[01:29:13.622]                       }
[01:29:13.622]                     }
[01:29:13.622]                     sendCondition <<- function(cond) NULL
[01:29:13.622]                   }
[01:29:13.622]                 })
[01:29:13.622]                 withCallingHandlers({
[01:29:13.622]                   {
[01:29:13.622]                     2
[01:29:13.622]                   }
[01:29:13.622]                 }, immediateCondition = function(cond) {
[01:29:13.622]                   sendCondition <- ...future.makeSendCondition()
[01:29:13.622]                   sendCondition(cond)
[01:29:13.622]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.622]                   {
[01:29:13.622]                     inherits <- base::inherits
[01:29:13.622]                     invokeRestart <- base::invokeRestart
[01:29:13.622]                     is.null <- base::is.null
[01:29:13.622]                     muffled <- FALSE
[01:29:13.622]                     if (inherits(cond, "message")) {
[01:29:13.622]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:13.622]                       if (muffled) 
[01:29:13.622]                         invokeRestart("muffleMessage")
[01:29:13.622]                     }
[01:29:13.622]                     else if (inherits(cond, "warning")) {
[01:29:13.622]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:13.622]                       if (muffled) 
[01:29:13.622]                         invokeRestart("muffleWarning")
[01:29:13.622]                     }
[01:29:13.622]                     else if (inherits(cond, "condition")) {
[01:29:13.622]                       if (!is.null(pattern)) {
[01:29:13.622]                         computeRestarts <- base::computeRestarts
[01:29:13.622]                         grepl <- base::grepl
[01:29:13.622]                         restarts <- computeRestarts(cond)
[01:29:13.622]                         for (restart in restarts) {
[01:29:13.622]                           name <- restart$name
[01:29:13.622]                           if (is.null(name)) 
[01:29:13.622]                             next
[01:29:13.622]                           if (!grepl(pattern, name)) 
[01:29:13.622]                             next
[01:29:13.622]                           invokeRestart(restart)
[01:29:13.622]                           muffled <- TRUE
[01:29:13.622]                           break
[01:29:13.622]                         }
[01:29:13.622]                       }
[01:29:13.622]                     }
[01:29:13.622]                     invisible(muffled)
[01:29:13.622]                   }
[01:29:13.622]                   muffleCondition(cond)
[01:29:13.622]                 })
[01:29:13.622]             }))
[01:29:13.622]             future::FutureResult(value = ...future.value$value, 
[01:29:13.622]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:13.622]                   ...future.rng), globalenv = if (FALSE) 
[01:29:13.622]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:13.622]                     ...future.globalenv.names))
[01:29:13.622]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:13.622]         }, condition = base::local({
[01:29:13.622]             c <- base::c
[01:29:13.622]             inherits <- base::inherits
[01:29:13.622]             invokeRestart <- base::invokeRestart
[01:29:13.622]             length <- base::length
[01:29:13.622]             list <- base::list
[01:29:13.622]             seq.int <- base::seq.int
[01:29:13.622]             signalCondition <- base::signalCondition
[01:29:13.622]             sys.calls <- base::sys.calls
[01:29:13.622]             `[[` <- base::`[[`
[01:29:13.622]             `+` <- base::`+`
[01:29:13.622]             `<<-` <- base::`<<-`
[01:29:13.622]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:13.622]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:13.622]                   3L)]
[01:29:13.622]             }
[01:29:13.622]             function(cond) {
[01:29:13.622]                 is_error <- inherits(cond, "error")
[01:29:13.622]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:13.622]                   NULL)
[01:29:13.622]                 if (is_error) {
[01:29:13.622]                   sessionInformation <- function() {
[01:29:13.622]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:13.622]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:13.622]                       search = base::search(), system = base::Sys.info())
[01:29:13.622]                   }
[01:29:13.622]                   ...future.conditions[[length(...future.conditions) + 
[01:29:13.622]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:13.622]                     cond$call), session = sessionInformation(), 
[01:29:13.622]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:13.622]                   signalCondition(cond)
[01:29:13.622]                 }
[01:29:13.622]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:13.622]                 "immediateCondition"))) {
[01:29:13.622]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:13.622]                   ...future.conditions[[length(...future.conditions) + 
[01:29:13.622]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:13.622]                   if (TRUE && !signal) {
[01:29:13.622]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.622]                     {
[01:29:13.622]                       inherits <- base::inherits
[01:29:13.622]                       invokeRestart <- base::invokeRestart
[01:29:13.622]                       is.null <- base::is.null
[01:29:13.622]                       muffled <- FALSE
[01:29:13.622]                       if (inherits(cond, "message")) {
[01:29:13.622]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:13.622]                         if (muffled) 
[01:29:13.622]                           invokeRestart("muffleMessage")
[01:29:13.622]                       }
[01:29:13.622]                       else if (inherits(cond, "warning")) {
[01:29:13.622]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:13.622]                         if (muffled) 
[01:29:13.622]                           invokeRestart("muffleWarning")
[01:29:13.622]                       }
[01:29:13.622]                       else if (inherits(cond, "condition")) {
[01:29:13.622]                         if (!is.null(pattern)) {
[01:29:13.622]                           computeRestarts <- base::computeRestarts
[01:29:13.622]                           grepl <- base::grepl
[01:29:13.622]                           restarts <- computeRestarts(cond)
[01:29:13.622]                           for (restart in restarts) {
[01:29:13.622]                             name <- restart$name
[01:29:13.622]                             if (is.null(name)) 
[01:29:13.622]                               next
[01:29:13.622]                             if (!grepl(pattern, name)) 
[01:29:13.622]                               next
[01:29:13.622]                             invokeRestart(restart)
[01:29:13.622]                             muffled <- TRUE
[01:29:13.622]                             break
[01:29:13.622]                           }
[01:29:13.622]                         }
[01:29:13.622]                       }
[01:29:13.622]                       invisible(muffled)
[01:29:13.622]                     }
[01:29:13.622]                     muffleCondition(cond, pattern = "^muffle")
[01:29:13.622]                   }
[01:29:13.622]                 }
[01:29:13.622]                 else {
[01:29:13.622]                   if (TRUE) {
[01:29:13.622]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.622]                     {
[01:29:13.622]                       inherits <- base::inherits
[01:29:13.622]                       invokeRestart <- base::invokeRestart
[01:29:13.622]                       is.null <- base::is.null
[01:29:13.622]                       muffled <- FALSE
[01:29:13.622]                       if (inherits(cond, "message")) {
[01:29:13.622]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:13.622]                         if (muffled) 
[01:29:13.622]                           invokeRestart("muffleMessage")
[01:29:13.622]                       }
[01:29:13.622]                       else if (inherits(cond, "warning")) {
[01:29:13.622]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:13.622]                         if (muffled) 
[01:29:13.622]                           invokeRestart("muffleWarning")
[01:29:13.622]                       }
[01:29:13.622]                       else if (inherits(cond, "condition")) {
[01:29:13.622]                         if (!is.null(pattern)) {
[01:29:13.622]                           computeRestarts <- base::computeRestarts
[01:29:13.622]                           grepl <- base::grepl
[01:29:13.622]                           restarts <- computeRestarts(cond)
[01:29:13.622]                           for (restart in restarts) {
[01:29:13.622]                             name <- restart$name
[01:29:13.622]                             if (is.null(name)) 
[01:29:13.622]                               next
[01:29:13.622]                             if (!grepl(pattern, name)) 
[01:29:13.622]                               next
[01:29:13.622]                             invokeRestart(restart)
[01:29:13.622]                             muffled <- TRUE
[01:29:13.622]                             break
[01:29:13.622]                           }
[01:29:13.622]                         }
[01:29:13.622]                       }
[01:29:13.622]                       invisible(muffled)
[01:29:13.622]                     }
[01:29:13.622]                     muffleCondition(cond, pattern = "^muffle")
[01:29:13.622]                   }
[01:29:13.622]                 }
[01:29:13.622]             }
[01:29:13.622]         }))
[01:29:13.622]     }, error = function(ex) {
[01:29:13.622]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:13.622]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:13.622]                 ...future.rng), started = ...future.startTime, 
[01:29:13.622]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:13.622]             version = "1.8"), class = "FutureResult")
[01:29:13.622]     }, finally = {
[01:29:13.622]         if (!identical(...future.workdir, getwd())) 
[01:29:13.622]             setwd(...future.workdir)
[01:29:13.622]         {
[01:29:13.622]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:13.622]                 ...future.oldOptions$nwarnings <- NULL
[01:29:13.622]             }
[01:29:13.622]             base::options(...future.oldOptions)
[01:29:13.622]             if (.Platform$OS.type == "windows") {
[01:29:13.622]                 old_names <- names(...future.oldEnvVars)
[01:29:13.622]                 envs <- base::Sys.getenv()
[01:29:13.622]                 names <- names(envs)
[01:29:13.622]                 common <- intersect(names, old_names)
[01:29:13.622]                 added <- setdiff(names, old_names)
[01:29:13.622]                 removed <- setdiff(old_names, names)
[01:29:13.622]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:13.622]                   envs[common]]
[01:29:13.622]                 NAMES <- toupper(changed)
[01:29:13.622]                 args <- list()
[01:29:13.622]                 for (kk in seq_along(NAMES)) {
[01:29:13.622]                   name <- changed[[kk]]
[01:29:13.622]                   NAME <- NAMES[[kk]]
[01:29:13.622]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.622]                     next
[01:29:13.622]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:13.622]                 }
[01:29:13.622]                 NAMES <- toupper(added)
[01:29:13.622]                 for (kk in seq_along(NAMES)) {
[01:29:13.622]                   name <- added[[kk]]
[01:29:13.622]                   NAME <- NAMES[[kk]]
[01:29:13.622]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.622]                     next
[01:29:13.622]                   args[[name]] <- ""
[01:29:13.622]                 }
[01:29:13.622]                 NAMES <- toupper(removed)
[01:29:13.622]                 for (kk in seq_along(NAMES)) {
[01:29:13.622]                   name <- removed[[kk]]
[01:29:13.622]                   NAME <- NAMES[[kk]]
[01:29:13.622]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.622]                     next
[01:29:13.622]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:13.622]                 }
[01:29:13.622]                 if (length(args) > 0) 
[01:29:13.622]                   base::do.call(base::Sys.setenv, args = args)
[01:29:13.622]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:13.622]             }
[01:29:13.622]             else {
[01:29:13.622]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:13.622]             }
[01:29:13.622]             {
[01:29:13.622]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:13.622]                   0L) {
[01:29:13.622]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:13.622]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:13.622]                   base::options(opts)
[01:29:13.622]                 }
[01:29:13.622]                 {
[01:29:13.622]                   {
[01:29:13.622]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:13.622]                     NULL
[01:29:13.622]                   }
[01:29:13.622]                   options(future.plan = NULL)
[01:29:13.622]                   if (is.na(NA_character_)) 
[01:29:13.622]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:13.622]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:13.622]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:13.622]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:13.622]                     envir = parent.frame()) 
[01:29:13.622]                   {
[01:29:13.622]                     if (is.function(workers)) 
[01:29:13.622]                       workers <- workers()
[01:29:13.622]                     workers <- structure(as.integer(workers), 
[01:29:13.622]                       class = class(workers))
[01:29:13.622]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:13.622]                       workers >= 1)
[01:29:13.622]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:13.622]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:13.622]                     }
[01:29:13.622]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:13.622]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:13.622]                       envir = envir)
[01:29:13.622]                     if (!future$lazy) 
[01:29:13.622]                       future <- run(future)
[01:29:13.622]                     invisible(future)
[01:29:13.622]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:13.622]                 }
[01:29:13.622]             }
[01:29:13.622]         }
[01:29:13.622]     })
[01:29:13.622]     if (TRUE) {
[01:29:13.622]         base::sink(type = "output", split = FALSE)
[01:29:13.622]         if (TRUE) {
[01:29:13.622]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:13.622]         }
[01:29:13.622]         else {
[01:29:13.622]             ...future.result["stdout"] <- base::list(NULL)
[01:29:13.622]         }
[01:29:13.622]         base::close(...future.stdout)
[01:29:13.622]         ...future.stdout <- NULL
[01:29:13.622]     }
[01:29:13.622]     ...future.result$conditions <- ...future.conditions
[01:29:13.622]     ...future.result$finished <- base::Sys.time()
[01:29:13.622]     ...future.result
[01:29:13.622] }
[01:29:13.629] MultisessionFuture started
[01:29:13.629] - Launch lazy future ... done
[01:29:13.629] run() for 'MultisessionFuture' ... done
[01:29:13.630] resolve() on environment ...
[01:29:13.630]  recursive: 0
[01:29:13.631]  elements: [3] 'a'
[01:29:13.631] receiveMessageFromWorker() for ClusterFuture ...
[01:29:13.632] - Validating connection of MultisessionFuture
[01:29:13.632] - received message: FutureResult
[01:29:13.632] - Received FutureResult
[01:29:13.632] - Erased future from FutureRegistry
[01:29:13.633] result() for ClusterFuture ...
[01:29:13.633] - result already collected: FutureResult
[01:29:13.633] result() for ClusterFuture ... done
[01:29:13.633] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:13.633] Future #1
[01:29:13.633]  length: 2 (resolved future 1)
[01:29:13.648] receiveMessageFromWorker() for ClusterFuture ...
[01:29:13.648] - Validating connection of MultisessionFuture
[01:29:13.648] - received message: FutureResult
[01:29:13.649] - Received FutureResult
[01:29:13.649] - Erased future from FutureRegistry
[01:29:13.649] result() for ClusterFuture ...
[01:29:13.649] - result already collected: FutureResult
[01:29:13.649] result() for ClusterFuture ... done
[01:29:13.649] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:13.650] Future #2
[01:29:13.650]  length: 1 (resolved future 2)
[01:29:13.650]  length: 0 (resolved future 3)
[01:29:13.650] resolve() on environment ... DONE
[01:29:13.651] resolve() on environment ...
[01:29:13.651]  recursive: 0
[01:29:13.652]  elements: [3] 'b'
[01:29:13.652] Future #1
[01:29:13.652]  length: 2 (resolved future 1)
[01:29:13.652] Future #2
[01:29:13.652]  length: 1 (resolved future 2)
[01:29:13.653]  length: 0 (resolved future 3)
[01:29:13.653] resolve() on environment ... DONE
[01:29:13.653] resolve() on environment ...
[01:29:13.654]  recursive: 0
[01:29:13.654]  elements: [3] 'c'
[01:29:13.654] Future #1
[01:29:13.655]  length: 2 (resolved future 1)
[01:29:13.655] Future #2
[01:29:13.655]  length: 1 (resolved future 2)
[01:29:13.655]  length: 0 (resolved future 3)
[01:29:13.655] resolve() on environment ... DONE
[01:29:13.656] resolve() on environment ...
[01:29:13.656]  recursive: 0
[01:29:13.657]  elements: [3] 'a', 'b', 'c', '.future_b'
[01:29:13.657] Future #1
[01:29:13.657] result() for ClusterFuture ...
[01:29:13.657] - result already collected: FutureResult
[01:29:13.658] result() for ClusterFuture ... done
[01:29:13.658] result() for ClusterFuture ...
[01:29:13.658] - result already collected: FutureResult
[01:29:13.658] result() for ClusterFuture ... done
[01:29:13.658]  length: 2 (resolved future 1)
[01:29:13.659] Future #2
[01:29:13.659] result() for ClusterFuture ...
[01:29:13.659] - result already collected: FutureResult
[01:29:13.659] result() for ClusterFuture ... done
[01:29:13.659] result() for ClusterFuture ...
[01:29:13.660] - result already collected: FutureResult
[01:29:13.660] result() for ClusterFuture ... done
[01:29:13.660]  length: 1 (resolved future 2)
[01:29:13.660]  length: 0 (resolved future 3)
[01:29:13.660] resolve() on environment ... DONE
[01:29:13.661] resolve() on environment ...
[01:29:13.661]  recursive: 99
[01:29:13.662]  elements: [3] '.future_b', 'a', 'b', 'c'
[01:29:13.662] Future #1
[01:29:13.662] result() for ClusterFuture ...
[01:29:13.662] - result already collected: FutureResult
[01:29:13.662] result() for ClusterFuture ... done
[01:29:13.663] result() for ClusterFuture ...
[01:29:13.663] - result already collected: FutureResult
[01:29:13.663] result() for ClusterFuture ... done
[01:29:13.663] A MultisessionFuture was resolved
[01:29:13.663]  length: 2 (resolved future 1)
[01:29:13.664] Future #2
[01:29:13.664] result() for ClusterFuture ...
[01:29:13.664] - result already collected: FutureResult
[01:29:13.664] result() for ClusterFuture ... done
[01:29:13.664] result() for ClusterFuture ...
[01:29:13.664] - result already collected: FutureResult
[01:29:13.664] result() for ClusterFuture ... done
[01:29:13.665] A MultisessionFuture was resolved
[01:29:13.665]  length: 1 (resolved future 2)
[01:29:13.665]  length: 0 (resolved future 3)
[01:29:13.665] resolve() on environment ... DONE
*** resolve() for environments ... DONE
*** resolve() for list environments ...
[01:29:13.666] resolve() on list environment ...
[01:29:13.666]  recursive: 0
[01:29:13.667]  length: 2
[01:29:13.667]  elements: 'a', 'b'
[01:29:13.667]  length: 1 (resolved future 1)
[01:29:13.668]  length: 0 (resolved future 2)
[01:29:13.668] resolve() on list environment ... DONE
[01:29:13.668] getGlobalsAndPackages() ...
[01:29:13.668] Searching for globals...
[01:29:13.669] 
[01:29:13.669] Searching for globals ... DONE
[01:29:13.669] - globals: [0] <none>
[01:29:13.669] getGlobalsAndPackages() ... DONE
[01:29:13.669] run() for 'Future' ...
[01:29:13.670] - state: 'created'
[01:29:13.670] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:13.684] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:13.685] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:13.685]   - Field: 'node'
[01:29:13.685]   - Field: 'label'
[01:29:13.685]   - Field: 'local'
[01:29:13.685]   - Field: 'owner'
[01:29:13.686]   - Field: 'envir'
[01:29:13.686]   - Field: 'workers'
[01:29:13.686]   - Field: 'packages'
[01:29:13.686]   - Field: 'gc'
[01:29:13.686]   - Field: 'conditions'
[01:29:13.686]   - Field: 'persistent'
[01:29:13.687]   - Field: 'expr'
[01:29:13.687]   - Field: 'uuid'
[01:29:13.687]   - Field: 'seed'
[01:29:13.687]   - Field: 'version'
[01:29:13.687]   - Field: 'result'
[01:29:13.687]   - Field: 'asynchronous'
[01:29:13.688]   - Field: 'calls'
[01:29:13.688]   - Field: 'globals'
[01:29:13.688]   - Field: 'stdout'
[01:29:13.688]   - Field: 'earlySignal'
[01:29:13.688]   - Field: 'lazy'
[01:29:13.689]   - Field: 'state'
[01:29:13.689] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:13.689] - Launch lazy future ...
[01:29:13.689] Packages needed by the future expression (n = 0): <none>
[01:29:13.690] Packages needed by future strategies (n = 0): <none>
[01:29:13.690] {
[01:29:13.690]     {
[01:29:13.690]         {
[01:29:13.690]             ...future.startTime <- base::Sys.time()
[01:29:13.690]             {
[01:29:13.690]                 {
[01:29:13.690]                   {
[01:29:13.690]                     {
[01:29:13.690]                       base::local({
[01:29:13.690]                         has_future <- base::requireNamespace("future", 
[01:29:13.690]                           quietly = TRUE)
[01:29:13.690]                         if (has_future) {
[01:29:13.690]                           ns <- base::getNamespace("future")
[01:29:13.690]                           version <- ns[[".package"]][["version"]]
[01:29:13.690]                           if (is.null(version)) 
[01:29:13.690]                             version <- utils::packageVersion("future")
[01:29:13.690]                         }
[01:29:13.690]                         else {
[01:29:13.690]                           version <- NULL
[01:29:13.690]                         }
[01:29:13.690]                         if (!has_future || version < "1.8.0") {
[01:29:13.690]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:13.690]                             "", base::R.version$version.string), 
[01:29:13.690]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:13.690]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:13.690]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:13.690]                               "release", "version")], collapse = " "), 
[01:29:13.690]                             hostname = base::Sys.info()[["nodename"]])
[01:29:13.690]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:13.690]                             info)
[01:29:13.690]                           info <- base::paste(info, collapse = "; ")
[01:29:13.690]                           if (!has_future) {
[01:29:13.690]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:13.690]                               info)
[01:29:13.690]                           }
[01:29:13.690]                           else {
[01:29:13.690]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:13.690]                               info, version)
[01:29:13.690]                           }
[01:29:13.690]                           base::stop(msg)
[01:29:13.690]                         }
[01:29:13.690]                       })
[01:29:13.690]                     }
[01:29:13.690]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:13.690]                     base::options(mc.cores = 1L)
[01:29:13.690]                   }
[01:29:13.690]                   options(future.plan = NULL)
[01:29:13.690]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:13.690]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:13.690]                 }
[01:29:13.690]                 ...future.workdir <- getwd()
[01:29:13.690]             }
[01:29:13.690]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:13.690]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:13.690]         }
[01:29:13.690]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:13.690]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:13.690]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:13.690]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:13.690]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:13.690]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:13.690]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:13.690]             base::names(...future.oldOptions))
[01:29:13.690]     }
[01:29:13.690]     if (FALSE) {
[01:29:13.690]     }
[01:29:13.690]     else {
[01:29:13.690]         if (TRUE) {
[01:29:13.690]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:13.690]                 open = "w")
[01:29:13.690]         }
[01:29:13.690]         else {
[01:29:13.690]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:13.690]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:13.690]         }
[01:29:13.690]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:13.690]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:13.690]             base::sink(type = "output", split = FALSE)
[01:29:13.690]             base::close(...future.stdout)
[01:29:13.690]         }, add = TRUE)
[01:29:13.690]     }
[01:29:13.690]     ...future.frame <- base::sys.nframe()
[01:29:13.690]     ...future.conditions <- base::list()
[01:29:13.690]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:13.690]     if (FALSE) {
[01:29:13.690]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:13.690]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:13.690]     }
[01:29:13.690]     ...future.result <- base::tryCatch({
[01:29:13.690]         base::withCallingHandlers({
[01:29:13.690]             ...future.value <- base::withVisible(base::local({
[01:29:13.690]                 ...future.makeSendCondition <- base::local({
[01:29:13.690]                   sendCondition <- NULL
[01:29:13.690]                   function(frame = 1L) {
[01:29:13.690]                     if (is.function(sendCondition)) 
[01:29:13.690]                       return(sendCondition)
[01:29:13.690]                     ns <- getNamespace("parallel")
[01:29:13.690]                     if (exists("sendData", mode = "function", 
[01:29:13.690]                       envir = ns)) {
[01:29:13.690]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:13.690]                         envir = ns)
[01:29:13.690]                       envir <- sys.frame(frame)
[01:29:13.690]                       master <- NULL
[01:29:13.690]                       while (!identical(envir, .GlobalEnv) && 
[01:29:13.690]                         !identical(envir, emptyenv())) {
[01:29:13.690]                         if (exists("master", mode = "list", envir = envir, 
[01:29:13.690]                           inherits = FALSE)) {
[01:29:13.690]                           master <- get("master", mode = "list", 
[01:29:13.690]                             envir = envir, inherits = FALSE)
[01:29:13.690]                           if (inherits(master, c("SOCKnode", 
[01:29:13.690]                             "SOCK0node"))) {
[01:29:13.690]                             sendCondition <<- function(cond) {
[01:29:13.690]                               data <- list(type = "VALUE", value = cond, 
[01:29:13.690]                                 success = TRUE)
[01:29:13.690]                               parallel_sendData(master, data)
[01:29:13.690]                             }
[01:29:13.690]                             return(sendCondition)
[01:29:13.690]                           }
[01:29:13.690]                         }
[01:29:13.690]                         frame <- frame + 1L
[01:29:13.690]                         envir <- sys.frame(frame)
[01:29:13.690]                       }
[01:29:13.690]                     }
[01:29:13.690]                     sendCondition <<- function(cond) NULL
[01:29:13.690]                   }
[01:29:13.690]                 })
[01:29:13.690]                 withCallingHandlers({
[01:29:13.690]                   1
[01:29:13.690]                 }, immediateCondition = function(cond) {
[01:29:13.690]                   sendCondition <- ...future.makeSendCondition()
[01:29:13.690]                   sendCondition(cond)
[01:29:13.690]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.690]                   {
[01:29:13.690]                     inherits <- base::inherits
[01:29:13.690]                     invokeRestart <- base::invokeRestart
[01:29:13.690]                     is.null <- base::is.null
[01:29:13.690]                     muffled <- FALSE
[01:29:13.690]                     if (inherits(cond, "message")) {
[01:29:13.690]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:13.690]                       if (muffled) 
[01:29:13.690]                         invokeRestart("muffleMessage")
[01:29:13.690]                     }
[01:29:13.690]                     else if (inherits(cond, "warning")) {
[01:29:13.690]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:13.690]                       if (muffled) 
[01:29:13.690]                         invokeRestart("muffleWarning")
[01:29:13.690]                     }
[01:29:13.690]                     else if (inherits(cond, "condition")) {
[01:29:13.690]                       if (!is.null(pattern)) {
[01:29:13.690]                         computeRestarts <- base::computeRestarts
[01:29:13.690]                         grepl <- base::grepl
[01:29:13.690]                         restarts <- computeRestarts(cond)
[01:29:13.690]                         for (restart in restarts) {
[01:29:13.690]                           name <- restart$name
[01:29:13.690]                           if (is.null(name)) 
[01:29:13.690]                             next
[01:29:13.690]                           if (!grepl(pattern, name)) 
[01:29:13.690]                             next
[01:29:13.690]                           invokeRestart(restart)
[01:29:13.690]                           muffled <- TRUE
[01:29:13.690]                           break
[01:29:13.690]                         }
[01:29:13.690]                       }
[01:29:13.690]                     }
[01:29:13.690]                     invisible(muffled)
[01:29:13.690]                   }
[01:29:13.690]                   muffleCondition(cond)
[01:29:13.690]                 })
[01:29:13.690]             }))
[01:29:13.690]             future::FutureResult(value = ...future.value$value, 
[01:29:13.690]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:13.690]                   ...future.rng), globalenv = if (FALSE) 
[01:29:13.690]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:13.690]                     ...future.globalenv.names))
[01:29:13.690]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:13.690]         }, condition = base::local({
[01:29:13.690]             c <- base::c
[01:29:13.690]             inherits <- base::inherits
[01:29:13.690]             invokeRestart <- base::invokeRestart
[01:29:13.690]             length <- base::length
[01:29:13.690]             list <- base::list
[01:29:13.690]             seq.int <- base::seq.int
[01:29:13.690]             signalCondition <- base::signalCondition
[01:29:13.690]             sys.calls <- base::sys.calls
[01:29:13.690]             `[[` <- base::`[[`
[01:29:13.690]             `+` <- base::`+`
[01:29:13.690]             `<<-` <- base::`<<-`
[01:29:13.690]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:13.690]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:13.690]                   3L)]
[01:29:13.690]             }
[01:29:13.690]             function(cond) {
[01:29:13.690]                 is_error <- inherits(cond, "error")
[01:29:13.690]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:13.690]                   NULL)
[01:29:13.690]                 if (is_error) {
[01:29:13.690]                   sessionInformation <- function() {
[01:29:13.690]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:13.690]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:13.690]                       search = base::search(), system = base::Sys.info())
[01:29:13.690]                   }
[01:29:13.690]                   ...future.conditions[[length(...future.conditions) + 
[01:29:13.690]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:13.690]                     cond$call), session = sessionInformation(), 
[01:29:13.690]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:13.690]                   signalCondition(cond)
[01:29:13.690]                 }
[01:29:13.690]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:13.690]                 "immediateCondition"))) {
[01:29:13.690]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:13.690]                   ...future.conditions[[length(...future.conditions) + 
[01:29:13.690]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:13.690]                   if (TRUE && !signal) {
[01:29:13.690]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.690]                     {
[01:29:13.690]                       inherits <- base::inherits
[01:29:13.690]                       invokeRestart <- base::invokeRestart
[01:29:13.690]                       is.null <- base::is.null
[01:29:13.690]                       muffled <- FALSE
[01:29:13.690]                       if (inherits(cond, "message")) {
[01:29:13.690]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:13.690]                         if (muffled) 
[01:29:13.690]                           invokeRestart("muffleMessage")
[01:29:13.690]                       }
[01:29:13.690]                       else if (inherits(cond, "warning")) {
[01:29:13.690]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:13.690]                         if (muffled) 
[01:29:13.690]                           invokeRestart("muffleWarning")
[01:29:13.690]                       }
[01:29:13.690]                       else if (inherits(cond, "condition")) {
[01:29:13.690]                         if (!is.null(pattern)) {
[01:29:13.690]                           computeRestarts <- base::computeRestarts
[01:29:13.690]                           grepl <- base::grepl
[01:29:13.690]                           restarts <- computeRestarts(cond)
[01:29:13.690]                           for (restart in restarts) {
[01:29:13.690]                             name <- restart$name
[01:29:13.690]                             if (is.null(name)) 
[01:29:13.690]                               next
[01:29:13.690]                             if (!grepl(pattern, name)) 
[01:29:13.690]                               next
[01:29:13.690]                             invokeRestart(restart)
[01:29:13.690]                             muffled <- TRUE
[01:29:13.690]                             break
[01:29:13.690]                           }
[01:29:13.690]                         }
[01:29:13.690]                       }
[01:29:13.690]                       invisible(muffled)
[01:29:13.690]                     }
[01:29:13.690]                     muffleCondition(cond, pattern = "^muffle")
[01:29:13.690]                   }
[01:29:13.690]                 }
[01:29:13.690]                 else {
[01:29:13.690]                   if (TRUE) {
[01:29:13.690]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.690]                     {
[01:29:13.690]                       inherits <- base::inherits
[01:29:13.690]                       invokeRestart <- base::invokeRestart
[01:29:13.690]                       is.null <- base::is.null
[01:29:13.690]                       muffled <- FALSE
[01:29:13.690]                       if (inherits(cond, "message")) {
[01:29:13.690]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:13.690]                         if (muffled) 
[01:29:13.690]                           invokeRestart("muffleMessage")
[01:29:13.690]                       }
[01:29:13.690]                       else if (inherits(cond, "warning")) {
[01:29:13.690]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:13.690]                         if (muffled) 
[01:29:13.690]                           invokeRestart("muffleWarning")
[01:29:13.690]                       }
[01:29:13.690]                       else if (inherits(cond, "condition")) {
[01:29:13.690]                         if (!is.null(pattern)) {
[01:29:13.690]                           computeRestarts <- base::computeRestarts
[01:29:13.690]                           grepl <- base::grepl
[01:29:13.690]                           restarts <- computeRestarts(cond)
[01:29:13.690]                           for (restart in restarts) {
[01:29:13.690]                             name <- restart$name
[01:29:13.690]                             if (is.null(name)) 
[01:29:13.690]                               next
[01:29:13.690]                             if (!grepl(pattern, name)) 
[01:29:13.690]                               next
[01:29:13.690]                             invokeRestart(restart)
[01:29:13.690]                             muffled <- TRUE
[01:29:13.690]                             break
[01:29:13.690]                           }
[01:29:13.690]                         }
[01:29:13.690]                       }
[01:29:13.690]                       invisible(muffled)
[01:29:13.690]                     }
[01:29:13.690]                     muffleCondition(cond, pattern = "^muffle")
[01:29:13.690]                   }
[01:29:13.690]                 }
[01:29:13.690]             }
[01:29:13.690]         }))
[01:29:13.690]     }, error = function(ex) {
[01:29:13.690]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:13.690]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:13.690]                 ...future.rng), started = ...future.startTime, 
[01:29:13.690]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:13.690]             version = "1.8"), class = "FutureResult")
[01:29:13.690]     }, finally = {
[01:29:13.690]         if (!identical(...future.workdir, getwd())) 
[01:29:13.690]             setwd(...future.workdir)
[01:29:13.690]         {
[01:29:13.690]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:13.690]                 ...future.oldOptions$nwarnings <- NULL
[01:29:13.690]             }
[01:29:13.690]             base::options(...future.oldOptions)
[01:29:13.690]             if (.Platform$OS.type == "windows") {
[01:29:13.690]                 old_names <- names(...future.oldEnvVars)
[01:29:13.690]                 envs <- base::Sys.getenv()
[01:29:13.690]                 names <- names(envs)
[01:29:13.690]                 common <- intersect(names, old_names)
[01:29:13.690]                 added <- setdiff(names, old_names)
[01:29:13.690]                 removed <- setdiff(old_names, names)
[01:29:13.690]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:13.690]                   envs[common]]
[01:29:13.690]                 NAMES <- toupper(changed)
[01:29:13.690]                 args <- list()
[01:29:13.690]                 for (kk in seq_along(NAMES)) {
[01:29:13.690]                   name <- changed[[kk]]
[01:29:13.690]                   NAME <- NAMES[[kk]]
[01:29:13.690]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.690]                     next
[01:29:13.690]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:13.690]                 }
[01:29:13.690]                 NAMES <- toupper(added)
[01:29:13.690]                 for (kk in seq_along(NAMES)) {
[01:29:13.690]                   name <- added[[kk]]
[01:29:13.690]                   NAME <- NAMES[[kk]]
[01:29:13.690]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.690]                     next
[01:29:13.690]                   args[[name]] <- ""
[01:29:13.690]                 }
[01:29:13.690]                 NAMES <- toupper(removed)
[01:29:13.690]                 for (kk in seq_along(NAMES)) {
[01:29:13.690]                   name <- removed[[kk]]
[01:29:13.690]                   NAME <- NAMES[[kk]]
[01:29:13.690]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.690]                     next
[01:29:13.690]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:13.690]                 }
[01:29:13.690]                 if (length(args) > 0) 
[01:29:13.690]                   base::do.call(base::Sys.setenv, args = args)
[01:29:13.690]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:13.690]             }
[01:29:13.690]             else {
[01:29:13.690]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:13.690]             }
[01:29:13.690]             {
[01:29:13.690]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:13.690]                   0L) {
[01:29:13.690]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:13.690]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:13.690]                   base::options(opts)
[01:29:13.690]                 }
[01:29:13.690]                 {
[01:29:13.690]                   {
[01:29:13.690]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:13.690]                     NULL
[01:29:13.690]                   }
[01:29:13.690]                   options(future.plan = NULL)
[01:29:13.690]                   if (is.na(NA_character_)) 
[01:29:13.690]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:13.690]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:13.690]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:13.690]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:13.690]                     envir = parent.frame()) 
[01:29:13.690]                   {
[01:29:13.690]                     if (is.function(workers)) 
[01:29:13.690]                       workers <- workers()
[01:29:13.690]                     workers <- structure(as.integer(workers), 
[01:29:13.690]                       class = class(workers))
[01:29:13.690]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:13.690]                       workers >= 1)
[01:29:13.690]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:13.690]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:13.690]                     }
[01:29:13.690]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:13.690]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:13.690]                       envir = envir)
[01:29:13.690]                     if (!future$lazy) 
[01:29:13.690]                       future <- run(future)
[01:29:13.690]                     invisible(future)
[01:29:13.690]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:13.690]                 }
[01:29:13.690]             }
[01:29:13.690]         }
[01:29:13.690]     })
[01:29:13.690]     if (TRUE) {
[01:29:13.690]         base::sink(type = "output", split = FALSE)
[01:29:13.690]         if (TRUE) {
[01:29:13.690]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:13.690]         }
[01:29:13.690]         else {
[01:29:13.690]             ...future.result["stdout"] <- base::list(NULL)
[01:29:13.690]         }
[01:29:13.690]         base::close(...future.stdout)
[01:29:13.690]         ...future.stdout <- NULL
[01:29:13.690]     }
[01:29:13.690]     ...future.result$conditions <- ...future.conditions
[01:29:13.690]     ...future.result$finished <- base::Sys.time()
[01:29:13.690]     ...future.result
[01:29:13.690] }
[01:29:13.697] MultisessionFuture started
[01:29:13.697] - Launch lazy future ... done
[01:29:13.697] run() for 'MultisessionFuture' ... done
[01:29:13.697] getGlobalsAndPackages() ...
[01:29:13.698] Searching for globals...
[01:29:13.698] 
[01:29:13.698] Searching for globals ... DONE
[01:29:13.698] - globals: [0] <none>
[01:29:13.699] getGlobalsAndPackages() ... DONE
[01:29:13.699] run() for 'Future' ...
[01:29:13.699] - state: 'created'
[01:29:13.699] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:13.714] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:13.714] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:13.715]   - Field: 'node'
[01:29:13.715]   - Field: 'label'
[01:29:13.715]   - Field: 'local'
[01:29:13.715]   - Field: 'owner'
[01:29:13.715]   - Field: 'envir'
[01:29:13.716]   - Field: 'workers'
[01:29:13.716]   - Field: 'packages'
[01:29:13.716]   - Field: 'gc'
[01:29:13.716]   - Field: 'conditions'
[01:29:13.716]   - Field: 'persistent'
[01:29:13.717]   - Field: 'expr'
[01:29:13.717]   - Field: 'uuid'
[01:29:13.717]   - Field: 'seed'
[01:29:13.717]   - Field: 'version'
[01:29:13.717]   - Field: 'result'
[01:29:13.718]   - Field: 'asynchronous'
[01:29:13.718]   - Field: 'calls'
[01:29:13.718]   - Field: 'globals'
[01:29:13.718]   - Field: 'stdout'
[01:29:13.718]   - Field: 'earlySignal'
[01:29:13.719]   - Field: 'lazy'
[01:29:13.719]   - Field: 'state'
[01:29:13.719] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:13.719] - Launch lazy future ...
[01:29:13.720] Packages needed by the future expression (n = 0): <none>
[01:29:13.720] Packages needed by future strategies (n = 0): <none>
[01:29:13.720] {
[01:29:13.720]     {
[01:29:13.720]         {
[01:29:13.720]             ...future.startTime <- base::Sys.time()
[01:29:13.720]             {
[01:29:13.720]                 {
[01:29:13.720]                   {
[01:29:13.720]                     {
[01:29:13.720]                       base::local({
[01:29:13.720]                         has_future <- base::requireNamespace("future", 
[01:29:13.720]                           quietly = TRUE)
[01:29:13.720]                         if (has_future) {
[01:29:13.720]                           ns <- base::getNamespace("future")
[01:29:13.720]                           version <- ns[[".package"]][["version"]]
[01:29:13.720]                           if (is.null(version)) 
[01:29:13.720]                             version <- utils::packageVersion("future")
[01:29:13.720]                         }
[01:29:13.720]                         else {
[01:29:13.720]                           version <- NULL
[01:29:13.720]                         }
[01:29:13.720]                         if (!has_future || version < "1.8.0") {
[01:29:13.720]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:13.720]                             "", base::R.version$version.string), 
[01:29:13.720]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:13.720]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:13.720]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:13.720]                               "release", "version")], collapse = " "), 
[01:29:13.720]                             hostname = base::Sys.info()[["nodename"]])
[01:29:13.720]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:13.720]                             info)
[01:29:13.720]                           info <- base::paste(info, collapse = "; ")
[01:29:13.720]                           if (!has_future) {
[01:29:13.720]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:13.720]                               info)
[01:29:13.720]                           }
[01:29:13.720]                           else {
[01:29:13.720]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:13.720]                               info, version)
[01:29:13.720]                           }
[01:29:13.720]                           base::stop(msg)
[01:29:13.720]                         }
[01:29:13.720]                       })
[01:29:13.720]                     }
[01:29:13.720]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:13.720]                     base::options(mc.cores = 1L)
[01:29:13.720]                   }
[01:29:13.720]                   options(future.plan = NULL)
[01:29:13.720]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:13.720]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:13.720]                 }
[01:29:13.720]                 ...future.workdir <- getwd()
[01:29:13.720]             }
[01:29:13.720]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:13.720]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:13.720]         }
[01:29:13.720]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:13.720]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:13.720]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:13.720]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:13.720]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:13.720]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:13.720]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:13.720]             base::names(...future.oldOptions))
[01:29:13.720]     }
[01:29:13.720]     if (FALSE) {
[01:29:13.720]     }
[01:29:13.720]     else {
[01:29:13.720]         if (TRUE) {
[01:29:13.720]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:13.720]                 open = "w")
[01:29:13.720]         }
[01:29:13.720]         else {
[01:29:13.720]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:13.720]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:13.720]         }
[01:29:13.720]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:13.720]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:13.720]             base::sink(type = "output", split = FALSE)
[01:29:13.720]             base::close(...future.stdout)
[01:29:13.720]         }, add = TRUE)
[01:29:13.720]     }
[01:29:13.720]     ...future.frame <- base::sys.nframe()
[01:29:13.720]     ...future.conditions <- base::list()
[01:29:13.720]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:13.720]     if (FALSE) {
[01:29:13.720]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:13.720]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:13.720]     }
[01:29:13.720]     ...future.result <- base::tryCatch({
[01:29:13.720]         base::withCallingHandlers({
[01:29:13.720]             ...future.value <- base::withVisible(base::local({
[01:29:13.720]                 ...future.makeSendCondition <- base::local({
[01:29:13.720]                   sendCondition <- NULL
[01:29:13.720]                   function(frame = 1L) {
[01:29:13.720]                     if (is.function(sendCondition)) 
[01:29:13.720]                       return(sendCondition)
[01:29:13.720]                     ns <- getNamespace("parallel")
[01:29:13.720]                     if (exists("sendData", mode = "function", 
[01:29:13.720]                       envir = ns)) {
[01:29:13.720]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:13.720]                         envir = ns)
[01:29:13.720]                       envir <- sys.frame(frame)
[01:29:13.720]                       master <- NULL
[01:29:13.720]                       while (!identical(envir, .GlobalEnv) && 
[01:29:13.720]                         !identical(envir, emptyenv())) {
[01:29:13.720]                         if (exists("master", mode = "list", envir = envir, 
[01:29:13.720]                           inherits = FALSE)) {
[01:29:13.720]                           master <- get("master", mode = "list", 
[01:29:13.720]                             envir = envir, inherits = FALSE)
[01:29:13.720]                           if (inherits(master, c("SOCKnode", 
[01:29:13.720]                             "SOCK0node"))) {
[01:29:13.720]                             sendCondition <<- function(cond) {
[01:29:13.720]                               data <- list(type = "VALUE", value = cond, 
[01:29:13.720]                                 success = TRUE)
[01:29:13.720]                               parallel_sendData(master, data)
[01:29:13.720]                             }
[01:29:13.720]                             return(sendCondition)
[01:29:13.720]                           }
[01:29:13.720]                         }
[01:29:13.720]                         frame <- frame + 1L
[01:29:13.720]                         envir <- sys.frame(frame)
[01:29:13.720]                       }
[01:29:13.720]                     }
[01:29:13.720]                     sendCondition <<- function(cond) NULL
[01:29:13.720]                   }
[01:29:13.720]                 })
[01:29:13.720]                 withCallingHandlers({
[01:29:13.720]                   2
[01:29:13.720]                 }, immediateCondition = function(cond) {
[01:29:13.720]                   sendCondition <- ...future.makeSendCondition()
[01:29:13.720]                   sendCondition(cond)
[01:29:13.720]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.720]                   {
[01:29:13.720]                     inherits <- base::inherits
[01:29:13.720]                     invokeRestart <- base::invokeRestart
[01:29:13.720]                     is.null <- base::is.null
[01:29:13.720]                     muffled <- FALSE
[01:29:13.720]                     if (inherits(cond, "message")) {
[01:29:13.720]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:13.720]                       if (muffled) 
[01:29:13.720]                         invokeRestart("muffleMessage")
[01:29:13.720]                     }
[01:29:13.720]                     else if (inherits(cond, "warning")) {
[01:29:13.720]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:13.720]                       if (muffled) 
[01:29:13.720]                         invokeRestart("muffleWarning")
[01:29:13.720]                     }
[01:29:13.720]                     else if (inherits(cond, "condition")) {
[01:29:13.720]                       if (!is.null(pattern)) {
[01:29:13.720]                         computeRestarts <- base::computeRestarts
[01:29:13.720]                         grepl <- base::grepl
[01:29:13.720]                         restarts <- computeRestarts(cond)
[01:29:13.720]                         for (restart in restarts) {
[01:29:13.720]                           name <- restart$name
[01:29:13.720]                           if (is.null(name)) 
[01:29:13.720]                             next
[01:29:13.720]                           if (!grepl(pattern, name)) 
[01:29:13.720]                             next
[01:29:13.720]                           invokeRestart(restart)
[01:29:13.720]                           muffled <- TRUE
[01:29:13.720]                           break
[01:29:13.720]                         }
[01:29:13.720]                       }
[01:29:13.720]                     }
[01:29:13.720]                     invisible(muffled)
[01:29:13.720]                   }
[01:29:13.720]                   muffleCondition(cond)
[01:29:13.720]                 })
[01:29:13.720]             }))
[01:29:13.720]             future::FutureResult(value = ...future.value$value, 
[01:29:13.720]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:13.720]                   ...future.rng), globalenv = if (FALSE) 
[01:29:13.720]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:13.720]                     ...future.globalenv.names))
[01:29:13.720]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:13.720]         }, condition = base::local({
[01:29:13.720]             c <- base::c
[01:29:13.720]             inherits <- base::inherits
[01:29:13.720]             invokeRestart <- base::invokeRestart
[01:29:13.720]             length <- base::length
[01:29:13.720]             list <- base::list
[01:29:13.720]             seq.int <- base::seq.int
[01:29:13.720]             signalCondition <- base::signalCondition
[01:29:13.720]             sys.calls <- base::sys.calls
[01:29:13.720]             `[[` <- base::`[[`
[01:29:13.720]             `+` <- base::`+`
[01:29:13.720]             `<<-` <- base::`<<-`
[01:29:13.720]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:13.720]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:13.720]                   3L)]
[01:29:13.720]             }
[01:29:13.720]             function(cond) {
[01:29:13.720]                 is_error <- inherits(cond, "error")
[01:29:13.720]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:13.720]                   NULL)
[01:29:13.720]                 if (is_error) {
[01:29:13.720]                   sessionInformation <- function() {
[01:29:13.720]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:13.720]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:13.720]                       search = base::search(), system = base::Sys.info())
[01:29:13.720]                   }
[01:29:13.720]                   ...future.conditions[[length(...future.conditions) + 
[01:29:13.720]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:13.720]                     cond$call), session = sessionInformation(), 
[01:29:13.720]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:13.720]                   signalCondition(cond)
[01:29:13.720]                 }
[01:29:13.720]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:13.720]                 "immediateCondition"))) {
[01:29:13.720]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:13.720]                   ...future.conditions[[length(...future.conditions) + 
[01:29:13.720]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:13.720]                   if (TRUE && !signal) {
[01:29:13.720]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.720]                     {
[01:29:13.720]                       inherits <- base::inherits
[01:29:13.720]                       invokeRestart <- base::invokeRestart
[01:29:13.720]                       is.null <- base::is.null
[01:29:13.720]                       muffled <- FALSE
[01:29:13.720]                       if (inherits(cond, "message")) {
[01:29:13.720]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:13.720]                         if (muffled) 
[01:29:13.720]                           invokeRestart("muffleMessage")
[01:29:13.720]                       }
[01:29:13.720]                       else if (inherits(cond, "warning")) {
[01:29:13.720]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:13.720]                         if (muffled) 
[01:29:13.720]                           invokeRestart("muffleWarning")
[01:29:13.720]                       }
[01:29:13.720]                       else if (inherits(cond, "condition")) {
[01:29:13.720]                         if (!is.null(pattern)) {
[01:29:13.720]                           computeRestarts <- base::computeRestarts
[01:29:13.720]                           grepl <- base::grepl
[01:29:13.720]                           restarts <- computeRestarts(cond)
[01:29:13.720]                           for (restart in restarts) {
[01:29:13.720]                             name <- restart$name
[01:29:13.720]                             if (is.null(name)) 
[01:29:13.720]                               next
[01:29:13.720]                             if (!grepl(pattern, name)) 
[01:29:13.720]                               next
[01:29:13.720]                             invokeRestart(restart)
[01:29:13.720]                             muffled <- TRUE
[01:29:13.720]                             break
[01:29:13.720]                           }
[01:29:13.720]                         }
[01:29:13.720]                       }
[01:29:13.720]                       invisible(muffled)
[01:29:13.720]                     }
[01:29:13.720]                     muffleCondition(cond, pattern = "^muffle")
[01:29:13.720]                   }
[01:29:13.720]                 }
[01:29:13.720]                 else {
[01:29:13.720]                   if (TRUE) {
[01:29:13.720]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.720]                     {
[01:29:13.720]                       inherits <- base::inherits
[01:29:13.720]                       invokeRestart <- base::invokeRestart
[01:29:13.720]                       is.null <- base::is.null
[01:29:13.720]                       muffled <- FALSE
[01:29:13.720]                       if (inherits(cond, "message")) {
[01:29:13.720]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:13.720]                         if (muffled) 
[01:29:13.720]                           invokeRestart("muffleMessage")
[01:29:13.720]                       }
[01:29:13.720]                       else if (inherits(cond, "warning")) {
[01:29:13.720]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:13.720]                         if (muffled) 
[01:29:13.720]                           invokeRestart("muffleWarning")
[01:29:13.720]                       }
[01:29:13.720]                       else if (inherits(cond, "condition")) {
[01:29:13.720]                         if (!is.null(pattern)) {
[01:29:13.720]                           computeRestarts <- base::computeRestarts
[01:29:13.720]                           grepl <- base::grepl
[01:29:13.720]                           restarts <- computeRestarts(cond)
[01:29:13.720]                           for (restart in restarts) {
[01:29:13.720]                             name <- restart$name
[01:29:13.720]                             if (is.null(name)) 
[01:29:13.720]                               next
[01:29:13.720]                             if (!grepl(pattern, name)) 
[01:29:13.720]                               next
[01:29:13.720]                             invokeRestart(restart)
[01:29:13.720]                             muffled <- TRUE
[01:29:13.720]                             break
[01:29:13.720]                           }
[01:29:13.720]                         }
[01:29:13.720]                       }
[01:29:13.720]                       invisible(muffled)
[01:29:13.720]                     }
[01:29:13.720]                     muffleCondition(cond, pattern = "^muffle")
[01:29:13.720]                   }
[01:29:13.720]                 }
[01:29:13.720]             }
[01:29:13.720]         }))
[01:29:13.720]     }, error = function(ex) {
[01:29:13.720]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:13.720]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:13.720]                 ...future.rng), started = ...future.startTime, 
[01:29:13.720]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:13.720]             version = "1.8"), class = "FutureResult")
[01:29:13.720]     }, finally = {
[01:29:13.720]         if (!identical(...future.workdir, getwd())) 
[01:29:13.720]             setwd(...future.workdir)
[01:29:13.720]         {
[01:29:13.720]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:13.720]                 ...future.oldOptions$nwarnings <- NULL
[01:29:13.720]             }
[01:29:13.720]             base::options(...future.oldOptions)
[01:29:13.720]             if (.Platform$OS.type == "windows") {
[01:29:13.720]                 old_names <- names(...future.oldEnvVars)
[01:29:13.720]                 envs <- base::Sys.getenv()
[01:29:13.720]                 names <- names(envs)
[01:29:13.720]                 common <- intersect(names, old_names)
[01:29:13.720]                 added <- setdiff(names, old_names)
[01:29:13.720]                 removed <- setdiff(old_names, names)
[01:29:13.720]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:13.720]                   envs[common]]
[01:29:13.720]                 NAMES <- toupper(changed)
[01:29:13.720]                 args <- list()
[01:29:13.720]                 for (kk in seq_along(NAMES)) {
[01:29:13.720]                   name <- changed[[kk]]
[01:29:13.720]                   NAME <- NAMES[[kk]]
[01:29:13.720]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.720]                     next
[01:29:13.720]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:13.720]                 }
[01:29:13.720]                 NAMES <- toupper(added)
[01:29:13.720]                 for (kk in seq_along(NAMES)) {
[01:29:13.720]                   name <- added[[kk]]
[01:29:13.720]                   NAME <- NAMES[[kk]]
[01:29:13.720]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.720]                     next
[01:29:13.720]                   args[[name]] <- ""
[01:29:13.720]                 }
[01:29:13.720]                 NAMES <- toupper(removed)
[01:29:13.720]                 for (kk in seq_along(NAMES)) {
[01:29:13.720]                   name <- removed[[kk]]
[01:29:13.720]                   NAME <- NAMES[[kk]]
[01:29:13.720]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.720]                     next
[01:29:13.720]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:13.720]                 }
[01:29:13.720]                 if (length(args) > 0) 
[01:29:13.720]                   base::do.call(base::Sys.setenv, args = args)
[01:29:13.720]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:13.720]             }
[01:29:13.720]             else {
[01:29:13.720]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:13.720]             }
[01:29:13.720]             {
[01:29:13.720]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:13.720]                   0L) {
[01:29:13.720]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:13.720]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:13.720]                   base::options(opts)
[01:29:13.720]                 }
[01:29:13.720]                 {
[01:29:13.720]                   {
[01:29:13.720]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:13.720]                     NULL
[01:29:13.720]                   }
[01:29:13.720]                   options(future.plan = NULL)
[01:29:13.720]                   if (is.na(NA_character_)) 
[01:29:13.720]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:13.720]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:13.720]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:13.720]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:13.720]                     envir = parent.frame()) 
[01:29:13.720]                   {
[01:29:13.720]                     if (is.function(workers)) 
[01:29:13.720]                       workers <- workers()
[01:29:13.720]                     workers <- structure(as.integer(workers), 
[01:29:13.720]                       class = class(workers))
[01:29:13.720]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:13.720]                       workers >= 1)
[01:29:13.720]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:13.720]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:13.720]                     }
[01:29:13.720]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:13.720]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:13.720]                       envir = envir)
[01:29:13.720]                     if (!future$lazy) 
[01:29:13.720]                       future <- run(future)
[01:29:13.720]                     invisible(future)
[01:29:13.720]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:13.720]                 }
[01:29:13.720]             }
[01:29:13.720]         }
[01:29:13.720]     })
[01:29:13.720]     if (TRUE) {
[01:29:13.720]         base::sink(type = "output", split = FALSE)
[01:29:13.720]         if (TRUE) {
[01:29:13.720]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:13.720]         }
[01:29:13.720]         else {
[01:29:13.720]             ...future.result["stdout"] <- base::list(NULL)
[01:29:13.720]         }
[01:29:13.720]         base::close(...future.stdout)
[01:29:13.720]         ...future.stdout <- NULL
[01:29:13.720]     }
[01:29:13.720]     ...future.result$conditions <- ...future.conditions
[01:29:13.720]     ...future.result$finished <- base::Sys.time()
[01:29:13.720]     ...future.result
[01:29:13.720] }
[01:29:13.727] MultisessionFuture started
[01:29:13.727] - Launch lazy future ... done
[01:29:13.727] run() for 'MultisessionFuture' ... done
[01:29:13.728] resolve() on list environment ...
[01:29:13.728]  recursive: 0
[01:29:13.729]  length: 3
[01:29:13.729]  elements: 'a', 'b', 'c'
[01:29:13.730] receiveMessageFromWorker() for ClusterFuture ...
[01:29:13.730] - Validating connection of MultisessionFuture
[01:29:13.730] - received message: FutureResult
[01:29:13.730] - Received FutureResult
[01:29:13.731] - Erased future from FutureRegistry
[01:29:13.731] result() for ClusterFuture ...
[01:29:13.731] - result already collected: FutureResult
[01:29:13.731] result() for ClusterFuture ... done
[01:29:13.731] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:13.731] Future #1
[01:29:13.732]  length: 2 (resolved future 1)
[01:29:13.745] receiveMessageFromWorker() for ClusterFuture ...
[01:29:13.745] - Validating connection of MultisessionFuture
[01:29:13.745] - received message: FutureResult
[01:29:13.746] - Received FutureResult
[01:29:13.746] - Erased future from FutureRegistry
[01:29:13.746] result() for ClusterFuture ...
[01:29:13.746] - result already collected: FutureResult
[01:29:13.746] result() for ClusterFuture ... done
[01:29:13.746] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:13.747] Future #2
[01:29:13.747]  length: 1 (resolved future 2)
[01:29:13.747]  length: 0 (resolved future 3)
[01:29:13.747] resolve() on list environment ... DONE
[01:29:13.748] getGlobalsAndPackages() ...
[01:29:13.748] Searching for globals...
[01:29:13.749] - globals found: [1] '{'
[01:29:13.749] Searching for globals ... DONE
[01:29:13.749] Resolving globals: FALSE
[01:29:13.750] 
[01:29:13.750] 
[01:29:13.750] getGlobalsAndPackages() ... DONE
[01:29:13.751] run() for 'Future' ...
[01:29:13.751] - state: 'created'
[01:29:13.751] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:13.766] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:13.766] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:13.766]   - Field: 'node'
[01:29:13.767]   - Field: 'label'
[01:29:13.767]   - Field: 'local'
[01:29:13.767]   - Field: 'owner'
[01:29:13.771]   - Field: 'envir'
[01:29:13.771]   - Field: 'workers'
[01:29:13.771]   - Field: 'packages'
[01:29:13.771]   - Field: 'gc'
[01:29:13.771]   - Field: 'conditions'
[01:29:13.772]   - Field: 'persistent'
[01:29:13.772]   - Field: 'expr'
[01:29:13.772]   - Field: 'uuid'
[01:29:13.772]   - Field: 'seed'
[01:29:13.772]   - Field: 'version'
[01:29:13.773]   - Field: 'result'
[01:29:13.773]   - Field: 'asynchronous'
[01:29:13.773]   - Field: 'calls'
[01:29:13.773]   - Field: 'globals'
[01:29:13.773]   - Field: 'stdout'
[01:29:13.773]   - Field: 'earlySignal'
[01:29:13.774]   - Field: 'lazy'
[01:29:13.774]   - Field: 'state'
[01:29:13.774] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:13.774] - Launch lazy future ...
[01:29:13.775] Packages needed by the future expression (n = 0): <none>
[01:29:13.775] Packages needed by future strategies (n = 0): <none>
[01:29:13.775] {
[01:29:13.775]     {
[01:29:13.775]         {
[01:29:13.775]             ...future.startTime <- base::Sys.time()
[01:29:13.775]             {
[01:29:13.775]                 {
[01:29:13.775]                   {
[01:29:13.775]                     {
[01:29:13.775]                       base::local({
[01:29:13.775]                         has_future <- base::requireNamespace("future", 
[01:29:13.775]                           quietly = TRUE)
[01:29:13.775]                         if (has_future) {
[01:29:13.775]                           ns <- base::getNamespace("future")
[01:29:13.775]                           version <- ns[[".package"]][["version"]]
[01:29:13.775]                           if (is.null(version)) 
[01:29:13.775]                             version <- utils::packageVersion("future")
[01:29:13.775]                         }
[01:29:13.775]                         else {
[01:29:13.775]                           version <- NULL
[01:29:13.775]                         }
[01:29:13.775]                         if (!has_future || version < "1.8.0") {
[01:29:13.775]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:13.775]                             "", base::R.version$version.string), 
[01:29:13.775]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:13.775]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:13.775]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:13.775]                               "release", "version")], collapse = " "), 
[01:29:13.775]                             hostname = base::Sys.info()[["nodename"]])
[01:29:13.775]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:13.775]                             info)
[01:29:13.775]                           info <- base::paste(info, collapse = "; ")
[01:29:13.775]                           if (!has_future) {
[01:29:13.775]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:13.775]                               info)
[01:29:13.775]                           }
[01:29:13.775]                           else {
[01:29:13.775]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:13.775]                               info, version)
[01:29:13.775]                           }
[01:29:13.775]                           base::stop(msg)
[01:29:13.775]                         }
[01:29:13.775]                       })
[01:29:13.775]                     }
[01:29:13.775]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:13.775]                     base::options(mc.cores = 1L)
[01:29:13.775]                   }
[01:29:13.775]                   options(future.plan = NULL)
[01:29:13.775]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:13.775]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:13.775]                 }
[01:29:13.775]                 ...future.workdir <- getwd()
[01:29:13.775]             }
[01:29:13.775]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:13.775]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:13.775]         }
[01:29:13.775]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:13.775]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:13.775]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:13.775]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:13.775]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:13.775]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:13.775]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:13.775]             base::names(...future.oldOptions))
[01:29:13.775]     }
[01:29:13.775]     if (FALSE) {
[01:29:13.775]     }
[01:29:13.775]     else {
[01:29:13.775]         if (TRUE) {
[01:29:13.775]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:13.775]                 open = "w")
[01:29:13.775]         }
[01:29:13.775]         else {
[01:29:13.775]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:13.775]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:13.775]         }
[01:29:13.775]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:13.775]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:13.775]             base::sink(type = "output", split = FALSE)
[01:29:13.775]             base::close(...future.stdout)
[01:29:13.775]         }, add = TRUE)
[01:29:13.775]     }
[01:29:13.775]     ...future.frame <- base::sys.nframe()
[01:29:13.775]     ...future.conditions <- base::list()
[01:29:13.775]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:13.775]     if (FALSE) {
[01:29:13.775]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:13.775]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:13.775]     }
[01:29:13.775]     ...future.result <- base::tryCatch({
[01:29:13.775]         base::withCallingHandlers({
[01:29:13.775]             ...future.value <- base::withVisible(base::local({
[01:29:13.775]                 ...future.makeSendCondition <- base::local({
[01:29:13.775]                   sendCondition <- NULL
[01:29:13.775]                   function(frame = 1L) {
[01:29:13.775]                     if (is.function(sendCondition)) 
[01:29:13.775]                       return(sendCondition)
[01:29:13.775]                     ns <- getNamespace("parallel")
[01:29:13.775]                     if (exists("sendData", mode = "function", 
[01:29:13.775]                       envir = ns)) {
[01:29:13.775]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:13.775]                         envir = ns)
[01:29:13.775]                       envir <- sys.frame(frame)
[01:29:13.775]                       master <- NULL
[01:29:13.775]                       while (!identical(envir, .GlobalEnv) && 
[01:29:13.775]                         !identical(envir, emptyenv())) {
[01:29:13.775]                         if (exists("master", mode = "list", envir = envir, 
[01:29:13.775]                           inherits = FALSE)) {
[01:29:13.775]                           master <- get("master", mode = "list", 
[01:29:13.775]                             envir = envir, inherits = FALSE)
[01:29:13.775]                           if (inherits(master, c("SOCKnode", 
[01:29:13.775]                             "SOCK0node"))) {
[01:29:13.775]                             sendCondition <<- function(cond) {
[01:29:13.775]                               data <- list(type = "VALUE", value = cond, 
[01:29:13.775]                                 success = TRUE)
[01:29:13.775]                               parallel_sendData(master, data)
[01:29:13.775]                             }
[01:29:13.775]                             return(sendCondition)
[01:29:13.775]                           }
[01:29:13.775]                         }
[01:29:13.775]                         frame <- frame + 1L
[01:29:13.775]                         envir <- sys.frame(frame)
[01:29:13.775]                       }
[01:29:13.775]                     }
[01:29:13.775]                     sendCondition <<- function(cond) NULL
[01:29:13.775]                   }
[01:29:13.775]                 })
[01:29:13.775]                 withCallingHandlers({
[01:29:13.775]                   {
[01:29:13.775]                     1
[01:29:13.775]                   }
[01:29:13.775]                 }, immediateCondition = function(cond) {
[01:29:13.775]                   sendCondition <- ...future.makeSendCondition()
[01:29:13.775]                   sendCondition(cond)
[01:29:13.775]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.775]                   {
[01:29:13.775]                     inherits <- base::inherits
[01:29:13.775]                     invokeRestart <- base::invokeRestart
[01:29:13.775]                     is.null <- base::is.null
[01:29:13.775]                     muffled <- FALSE
[01:29:13.775]                     if (inherits(cond, "message")) {
[01:29:13.775]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:13.775]                       if (muffled) 
[01:29:13.775]                         invokeRestart("muffleMessage")
[01:29:13.775]                     }
[01:29:13.775]                     else if (inherits(cond, "warning")) {
[01:29:13.775]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:13.775]                       if (muffled) 
[01:29:13.775]                         invokeRestart("muffleWarning")
[01:29:13.775]                     }
[01:29:13.775]                     else if (inherits(cond, "condition")) {
[01:29:13.775]                       if (!is.null(pattern)) {
[01:29:13.775]                         computeRestarts <- base::computeRestarts
[01:29:13.775]                         grepl <- base::grepl
[01:29:13.775]                         restarts <- computeRestarts(cond)
[01:29:13.775]                         for (restart in restarts) {
[01:29:13.775]                           name <- restart$name
[01:29:13.775]                           if (is.null(name)) 
[01:29:13.775]                             next
[01:29:13.775]                           if (!grepl(pattern, name)) 
[01:29:13.775]                             next
[01:29:13.775]                           invokeRestart(restart)
[01:29:13.775]                           muffled <- TRUE
[01:29:13.775]                           break
[01:29:13.775]                         }
[01:29:13.775]                       }
[01:29:13.775]                     }
[01:29:13.775]                     invisible(muffled)
[01:29:13.775]                   }
[01:29:13.775]                   muffleCondition(cond)
[01:29:13.775]                 })
[01:29:13.775]             }))
[01:29:13.775]             future::FutureResult(value = ...future.value$value, 
[01:29:13.775]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:13.775]                   ...future.rng), globalenv = if (FALSE) 
[01:29:13.775]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:13.775]                     ...future.globalenv.names))
[01:29:13.775]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:13.775]         }, condition = base::local({
[01:29:13.775]             c <- base::c
[01:29:13.775]             inherits <- base::inherits
[01:29:13.775]             invokeRestart <- base::invokeRestart
[01:29:13.775]             length <- base::length
[01:29:13.775]             list <- base::list
[01:29:13.775]             seq.int <- base::seq.int
[01:29:13.775]             signalCondition <- base::signalCondition
[01:29:13.775]             sys.calls <- base::sys.calls
[01:29:13.775]             `[[` <- base::`[[`
[01:29:13.775]             `+` <- base::`+`
[01:29:13.775]             `<<-` <- base::`<<-`
[01:29:13.775]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:13.775]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:13.775]                   3L)]
[01:29:13.775]             }
[01:29:13.775]             function(cond) {
[01:29:13.775]                 is_error <- inherits(cond, "error")
[01:29:13.775]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:13.775]                   NULL)
[01:29:13.775]                 if (is_error) {
[01:29:13.775]                   sessionInformation <- function() {
[01:29:13.775]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:13.775]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:13.775]                       search = base::search(), system = base::Sys.info())
[01:29:13.775]                   }
[01:29:13.775]                   ...future.conditions[[length(...future.conditions) + 
[01:29:13.775]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:13.775]                     cond$call), session = sessionInformation(), 
[01:29:13.775]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:13.775]                   signalCondition(cond)
[01:29:13.775]                 }
[01:29:13.775]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:13.775]                 "immediateCondition"))) {
[01:29:13.775]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:13.775]                   ...future.conditions[[length(...future.conditions) + 
[01:29:13.775]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:13.775]                   if (TRUE && !signal) {
[01:29:13.775]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.775]                     {
[01:29:13.775]                       inherits <- base::inherits
[01:29:13.775]                       invokeRestart <- base::invokeRestart
[01:29:13.775]                       is.null <- base::is.null
[01:29:13.775]                       muffled <- FALSE
[01:29:13.775]                       if (inherits(cond, "message")) {
[01:29:13.775]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:13.775]                         if (muffled) 
[01:29:13.775]                           invokeRestart("muffleMessage")
[01:29:13.775]                       }
[01:29:13.775]                       else if (inherits(cond, "warning")) {
[01:29:13.775]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:13.775]                         if (muffled) 
[01:29:13.775]                           invokeRestart("muffleWarning")
[01:29:13.775]                       }
[01:29:13.775]                       else if (inherits(cond, "condition")) {
[01:29:13.775]                         if (!is.null(pattern)) {
[01:29:13.775]                           computeRestarts <- base::computeRestarts
[01:29:13.775]                           grepl <- base::grepl
[01:29:13.775]                           restarts <- computeRestarts(cond)
[01:29:13.775]                           for (restart in restarts) {
[01:29:13.775]                             name <- restart$name
[01:29:13.775]                             if (is.null(name)) 
[01:29:13.775]                               next
[01:29:13.775]                             if (!grepl(pattern, name)) 
[01:29:13.775]                               next
[01:29:13.775]                             invokeRestart(restart)
[01:29:13.775]                             muffled <- TRUE
[01:29:13.775]                             break
[01:29:13.775]                           }
[01:29:13.775]                         }
[01:29:13.775]                       }
[01:29:13.775]                       invisible(muffled)
[01:29:13.775]                     }
[01:29:13.775]                     muffleCondition(cond, pattern = "^muffle")
[01:29:13.775]                   }
[01:29:13.775]                 }
[01:29:13.775]                 else {
[01:29:13.775]                   if (TRUE) {
[01:29:13.775]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.775]                     {
[01:29:13.775]                       inherits <- base::inherits
[01:29:13.775]                       invokeRestart <- base::invokeRestart
[01:29:13.775]                       is.null <- base::is.null
[01:29:13.775]                       muffled <- FALSE
[01:29:13.775]                       if (inherits(cond, "message")) {
[01:29:13.775]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:13.775]                         if (muffled) 
[01:29:13.775]                           invokeRestart("muffleMessage")
[01:29:13.775]                       }
[01:29:13.775]                       else if (inherits(cond, "warning")) {
[01:29:13.775]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:13.775]                         if (muffled) 
[01:29:13.775]                           invokeRestart("muffleWarning")
[01:29:13.775]                       }
[01:29:13.775]                       else if (inherits(cond, "condition")) {
[01:29:13.775]                         if (!is.null(pattern)) {
[01:29:13.775]                           computeRestarts <- base::computeRestarts
[01:29:13.775]                           grepl <- base::grepl
[01:29:13.775]                           restarts <- computeRestarts(cond)
[01:29:13.775]                           for (restart in restarts) {
[01:29:13.775]                             name <- restart$name
[01:29:13.775]                             if (is.null(name)) 
[01:29:13.775]                               next
[01:29:13.775]                             if (!grepl(pattern, name)) 
[01:29:13.775]                               next
[01:29:13.775]                             invokeRestart(restart)
[01:29:13.775]                             muffled <- TRUE
[01:29:13.775]                             break
[01:29:13.775]                           }
[01:29:13.775]                         }
[01:29:13.775]                       }
[01:29:13.775]                       invisible(muffled)
[01:29:13.775]                     }
[01:29:13.775]                     muffleCondition(cond, pattern = "^muffle")
[01:29:13.775]                   }
[01:29:13.775]                 }
[01:29:13.775]             }
[01:29:13.775]         }))
[01:29:13.775]     }, error = function(ex) {
[01:29:13.775]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:13.775]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:13.775]                 ...future.rng), started = ...future.startTime, 
[01:29:13.775]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:13.775]             version = "1.8"), class = "FutureResult")
[01:29:13.775]     }, finally = {
[01:29:13.775]         if (!identical(...future.workdir, getwd())) 
[01:29:13.775]             setwd(...future.workdir)
[01:29:13.775]         {
[01:29:13.775]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:13.775]                 ...future.oldOptions$nwarnings <- NULL
[01:29:13.775]             }
[01:29:13.775]             base::options(...future.oldOptions)
[01:29:13.775]             if (.Platform$OS.type == "windows") {
[01:29:13.775]                 old_names <- names(...future.oldEnvVars)
[01:29:13.775]                 envs <- base::Sys.getenv()
[01:29:13.775]                 names <- names(envs)
[01:29:13.775]                 common <- intersect(names, old_names)
[01:29:13.775]                 added <- setdiff(names, old_names)
[01:29:13.775]                 removed <- setdiff(old_names, names)
[01:29:13.775]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:13.775]                   envs[common]]
[01:29:13.775]                 NAMES <- toupper(changed)
[01:29:13.775]                 args <- list()
[01:29:13.775]                 for (kk in seq_along(NAMES)) {
[01:29:13.775]                   name <- changed[[kk]]
[01:29:13.775]                   NAME <- NAMES[[kk]]
[01:29:13.775]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.775]                     next
[01:29:13.775]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:13.775]                 }
[01:29:13.775]                 NAMES <- toupper(added)
[01:29:13.775]                 for (kk in seq_along(NAMES)) {
[01:29:13.775]                   name <- added[[kk]]
[01:29:13.775]                   NAME <- NAMES[[kk]]
[01:29:13.775]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.775]                     next
[01:29:13.775]                   args[[name]] <- ""
[01:29:13.775]                 }
[01:29:13.775]                 NAMES <- toupper(removed)
[01:29:13.775]                 for (kk in seq_along(NAMES)) {
[01:29:13.775]                   name <- removed[[kk]]
[01:29:13.775]                   NAME <- NAMES[[kk]]
[01:29:13.775]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.775]                     next
[01:29:13.775]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:13.775]                 }
[01:29:13.775]                 if (length(args) > 0) 
[01:29:13.775]                   base::do.call(base::Sys.setenv, args = args)
[01:29:13.775]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:13.775]             }
[01:29:13.775]             else {
[01:29:13.775]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:13.775]             }
[01:29:13.775]             {
[01:29:13.775]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:13.775]                   0L) {
[01:29:13.775]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:13.775]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:13.775]                   base::options(opts)
[01:29:13.775]                 }
[01:29:13.775]                 {
[01:29:13.775]                   {
[01:29:13.775]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:13.775]                     NULL
[01:29:13.775]                   }
[01:29:13.775]                   options(future.plan = NULL)
[01:29:13.775]                   if (is.na(NA_character_)) 
[01:29:13.775]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:13.775]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:13.775]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:13.775]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:13.775]                     envir = parent.frame()) 
[01:29:13.775]                   {
[01:29:13.775]                     if (is.function(workers)) 
[01:29:13.775]                       workers <- workers()
[01:29:13.775]                     workers <- structure(as.integer(workers), 
[01:29:13.775]                       class = class(workers))
[01:29:13.775]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:13.775]                       workers >= 1)
[01:29:13.775]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:13.775]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:13.775]                     }
[01:29:13.775]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:13.775]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:13.775]                       envir = envir)
[01:29:13.775]                     if (!future$lazy) 
[01:29:13.775]                       future <- run(future)
[01:29:13.775]                     invisible(future)
[01:29:13.775]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:13.775]                 }
[01:29:13.775]             }
[01:29:13.775]         }
[01:29:13.775]     })
[01:29:13.775]     if (TRUE) {
[01:29:13.775]         base::sink(type = "output", split = FALSE)
[01:29:13.775]         if (TRUE) {
[01:29:13.775]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:13.775]         }
[01:29:13.775]         else {
[01:29:13.775]             ...future.result["stdout"] <- base::list(NULL)
[01:29:13.775]         }
[01:29:13.775]         base::close(...future.stdout)
[01:29:13.775]         ...future.stdout <- NULL
[01:29:13.775]     }
[01:29:13.775]     ...future.result$conditions <- ...future.conditions
[01:29:13.775]     ...future.result$finished <- base::Sys.time()
[01:29:13.775]     ...future.result
[01:29:13.775] }
[01:29:13.781] MultisessionFuture started
[01:29:13.782] - Launch lazy future ... done
[01:29:13.782] run() for 'MultisessionFuture' ... done
[01:29:13.783] getGlobalsAndPackages() ...
[01:29:13.783] Searching for globals...
[01:29:13.784] - globals found: [1] '{'
[01:29:13.784] Searching for globals ... DONE
[01:29:13.784] Resolving globals: FALSE
[01:29:13.785] 
[01:29:13.785] 
[01:29:13.785] getGlobalsAndPackages() ... DONE
[01:29:13.785] run() for 'Future' ...
[01:29:13.786] - state: 'created'
[01:29:13.786] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:13.800] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:13.800] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:13.801]   - Field: 'node'
[01:29:13.801]   - Field: 'label'
[01:29:13.801]   - Field: 'local'
[01:29:13.801]   - Field: 'owner'
[01:29:13.801]   - Field: 'envir'
[01:29:13.802]   - Field: 'workers'
[01:29:13.802]   - Field: 'packages'
[01:29:13.802]   - Field: 'gc'
[01:29:13.802]   - Field: 'conditions'
[01:29:13.802]   - Field: 'persistent'
[01:29:13.803]   - Field: 'expr'
[01:29:13.803]   - Field: 'uuid'
[01:29:13.803]   - Field: 'seed'
[01:29:13.803]   - Field: 'version'
[01:29:13.803]   - Field: 'result'
[01:29:13.803]   - Field: 'asynchronous'
[01:29:13.804]   - Field: 'calls'
[01:29:13.804]   - Field: 'globals'
[01:29:13.804]   - Field: 'stdout'
[01:29:13.804]   - Field: 'earlySignal'
[01:29:13.804]   - Field: 'lazy'
[01:29:13.804]   - Field: 'state'
[01:29:13.805] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:13.805] - Launch lazy future ...
[01:29:13.805] Packages needed by the future expression (n = 0): <none>
[01:29:13.806] Packages needed by future strategies (n = 0): <none>
[01:29:13.806] {
[01:29:13.806]     {
[01:29:13.806]         {
[01:29:13.806]             ...future.startTime <- base::Sys.time()
[01:29:13.806]             {
[01:29:13.806]                 {
[01:29:13.806]                   {
[01:29:13.806]                     {
[01:29:13.806]                       base::local({
[01:29:13.806]                         has_future <- base::requireNamespace("future", 
[01:29:13.806]                           quietly = TRUE)
[01:29:13.806]                         if (has_future) {
[01:29:13.806]                           ns <- base::getNamespace("future")
[01:29:13.806]                           version <- ns[[".package"]][["version"]]
[01:29:13.806]                           if (is.null(version)) 
[01:29:13.806]                             version <- utils::packageVersion("future")
[01:29:13.806]                         }
[01:29:13.806]                         else {
[01:29:13.806]                           version <- NULL
[01:29:13.806]                         }
[01:29:13.806]                         if (!has_future || version < "1.8.0") {
[01:29:13.806]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:13.806]                             "", base::R.version$version.string), 
[01:29:13.806]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:13.806]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:13.806]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:13.806]                               "release", "version")], collapse = " "), 
[01:29:13.806]                             hostname = base::Sys.info()[["nodename"]])
[01:29:13.806]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:13.806]                             info)
[01:29:13.806]                           info <- base::paste(info, collapse = "; ")
[01:29:13.806]                           if (!has_future) {
[01:29:13.806]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:13.806]                               info)
[01:29:13.806]                           }
[01:29:13.806]                           else {
[01:29:13.806]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:13.806]                               info, version)
[01:29:13.806]                           }
[01:29:13.806]                           base::stop(msg)
[01:29:13.806]                         }
[01:29:13.806]                       })
[01:29:13.806]                     }
[01:29:13.806]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:13.806]                     base::options(mc.cores = 1L)
[01:29:13.806]                   }
[01:29:13.806]                   options(future.plan = NULL)
[01:29:13.806]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:13.806]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:13.806]                 }
[01:29:13.806]                 ...future.workdir <- getwd()
[01:29:13.806]             }
[01:29:13.806]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:13.806]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:13.806]         }
[01:29:13.806]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:13.806]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:13.806]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:13.806]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:13.806]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:13.806]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:13.806]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:13.806]             base::names(...future.oldOptions))
[01:29:13.806]     }
[01:29:13.806]     if (FALSE) {
[01:29:13.806]     }
[01:29:13.806]     else {
[01:29:13.806]         if (TRUE) {
[01:29:13.806]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:13.806]                 open = "w")
[01:29:13.806]         }
[01:29:13.806]         else {
[01:29:13.806]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:13.806]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:13.806]         }
[01:29:13.806]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:13.806]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:13.806]             base::sink(type = "output", split = FALSE)
[01:29:13.806]             base::close(...future.stdout)
[01:29:13.806]         }, add = TRUE)
[01:29:13.806]     }
[01:29:13.806]     ...future.frame <- base::sys.nframe()
[01:29:13.806]     ...future.conditions <- base::list()
[01:29:13.806]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:13.806]     if (FALSE) {
[01:29:13.806]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:13.806]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:13.806]     }
[01:29:13.806]     ...future.result <- base::tryCatch({
[01:29:13.806]         base::withCallingHandlers({
[01:29:13.806]             ...future.value <- base::withVisible(base::local({
[01:29:13.806]                 ...future.makeSendCondition <- base::local({
[01:29:13.806]                   sendCondition <- NULL
[01:29:13.806]                   function(frame = 1L) {
[01:29:13.806]                     if (is.function(sendCondition)) 
[01:29:13.806]                       return(sendCondition)
[01:29:13.806]                     ns <- getNamespace("parallel")
[01:29:13.806]                     if (exists("sendData", mode = "function", 
[01:29:13.806]                       envir = ns)) {
[01:29:13.806]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:13.806]                         envir = ns)
[01:29:13.806]                       envir <- sys.frame(frame)
[01:29:13.806]                       master <- NULL
[01:29:13.806]                       while (!identical(envir, .GlobalEnv) && 
[01:29:13.806]                         !identical(envir, emptyenv())) {
[01:29:13.806]                         if (exists("master", mode = "list", envir = envir, 
[01:29:13.806]                           inherits = FALSE)) {
[01:29:13.806]                           master <- get("master", mode = "list", 
[01:29:13.806]                             envir = envir, inherits = FALSE)
[01:29:13.806]                           if (inherits(master, c("SOCKnode", 
[01:29:13.806]                             "SOCK0node"))) {
[01:29:13.806]                             sendCondition <<- function(cond) {
[01:29:13.806]                               data <- list(type = "VALUE", value = cond, 
[01:29:13.806]                                 success = TRUE)
[01:29:13.806]                               parallel_sendData(master, data)
[01:29:13.806]                             }
[01:29:13.806]                             return(sendCondition)
[01:29:13.806]                           }
[01:29:13.806]                         }
[01:29:13.806]                         frame <- frame + 1L
[01:29:13.806]                         envir <- sys.frame(frame)
[01:29:13.806]                       }
[01:29:13.806]                     }
[01:29:13.806]                     sendCondition <<- function(cond) NULL
[01:29:13.806]                   }
[01:29:13.806]                 })
[01:29:13.806]                 withCallingHandlers({
[01:29:13.806]                   {
[01:29:13.806]                     2
[01:29:13.806]                   }
[01:29:13.806]                 }, immediateCondition = function(cond) {
[01:29:13.806]                   sendCondition <- ...future.makeSendCondition()
[01:29:13.806]                   sendCondition(cond)
[01:29:13.806]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.806]                   {
[01:29:13.806]                     inherits <- base::inherits
[01:29:13.806]                     invokeRestart <- base::invokeRestart
[01:29:13.806]                     is.null <- base::is.null
[01:29:13.806]                     muffled <- FALSE
[01:29:13.806]                     if (inherits(cond, "message")) {
[01:29:13.806]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:13.806]                       if (muffled) 
[01:29:13.806]                         invokeRestart("muffleMessage")
[01:29:13.806]                     }
[01:29:13.806]                     else if (inherits(cond, "warning")) {
[01:29:13.806]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:13.806]                       if (muffled) 
[01:29:13.806]                         invokeRestart("muffleWarning")
[01:29:13.806]                     }
[01:29:13.806]                     else if (inherits(cond, "condition")) {
[01:29:13.806]                       if (!is.null(pattern)) {
[01:29:13.806]                         computeRestarts <- base::computeRestarts
[01:29:13.806]                         grepl <- base::grepl
[01:29:13.806]                         restarts <- computeRestarts(cond)
[01:29:13.806]                         for (restart in restarts) {
[01:29:13.806]                           name <- restart$name
[01:29:13.806]                           if (is.null(name)) 
[01:29:13.806]                             next
[01:29:13.806]                           if (!grepl(pattern, name)) 
[01:29:13.806]                             next
[01:29:13.806]                           invokeRestart(restart)
[01:29:13.806]                           muffled <- TRUE
[01:29:13.806]                           break
[01:29:13.806]                         }
[01:29:13.806]                       }
[01:29:13.806]                     }
[01:29:13.806]                     invisible(muffled)
[01:29:13.806]                   }
[01:29:13.806]                   muffleCondition(cond)
[01:29:13.806]                 })
[01:29:13.806]             }))
[01:29:13.806]             future::FutureResult(value = ...future.value$value, 
[01:29:13.806]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:13.806]                   ...future.rng), globalenv = if (FALSE) 
[01:29:13.806]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:13.806]                     ...future.globalenv.names))
[01:29:13.806]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:13.806]         }, condition = base::local({
[01:29:13.806]             c <- base::c
[01:29:13.806]             inherits <- base::inherits
[01:29:13.806]             invokeRestart <- base::invokeRestart
[01:29:13.806]             length <- base::length
[01:29:13.806]             list <- base::list
[01:29:13.806]             seq.int <- base::seq.int
[01:29:13.806]             signalCondition <- base::signalCondition
[01:29:13.806]             sys.calls <- base::sys.calls
[01:29:13.806]             `[[` <- base::`[[`
[01:29:13.806]             `+` <- base::`+`
[01:29:13.806]             `<<-` <- base::`<<-`
[01:29:13.806]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:13.806]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:13.806]                   3L)]
[01:29:13.806]             }
[01:29:13.806]             function(cond) {
[01:29:13.806]                 is_error <- inherits(cond, "error")
[01:29:13.806]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:13.806]                   NULL)
[01:29:13.806]                 if (is_error) {
[01:29:13.806]                   sessionInformation <- function() {
[01:29:13.806]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:13.806]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:13.806]                       search = base::search(), system = base::Sys.info())
[01:29:13.806]                   }
[01:29:13.806]                   ...future.conditions[[length(...future.conditions) + 
[01:29:13.806]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:13.806]                     cond$call), session = sessionInformation(), 
[01:29:13.806]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:13.806]                   signalCondition(cond)
[01:29:13.806]                 }
[01:29:13.806]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:13.806]                 "immediateCondition"))) {
[01:29:13.806]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:13.806]                   ...future.conditions[[length(...future.conditions) + 
[01:29:13.806]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:13.806]                   if (TRUE && !signal) {
[01:29:13.806]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.806]                     {
[01:29:13.806]                       inherits <- base::inherits
[01:29:13.806]                       invokeRestart <- base::invokeRestart
[01:29:13.806]                       is.null <- base::is.null
[01:29:13.806]                       muffled <- FALSE
[01:29:13.806]                       if (inherits(cond, "message")) {
[01:29:13.806]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:13.806]                         if (muffled) 
[01:29:13.806]                           invokeRestart("muffleMessage")
[01:29:13.806]                       }
[01:29:13.806]                       else if (inherits(cond, "warning")) {
[01:29:13.806]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:13.806]                         if (muffled) 
[01:29:13.806]                           invokeRestart("muffleWarning")
[01:29:13.806]                       }
[01:29:13.806]                       else if (inherits(cond, "condition")) {
[01:29:13.806]                         if (!is.null(pattern)) {
[01:29:13.806]                           computeRestarts <- base::computeRestarts
[01:29:13.806]                           grepl <- base::grepl
[01:29:13.806]                           restarts <- computeRestarts(cond)
[01:29:13.806]                           for (restart in restarts) {
[01:29:13.806]                             name <- restart$name
[01:29:13.806]                             if (is.null(name)) 
[01:29:13.806]                               next
[01:29:13.806]                             if (!grepl(pattern, name)) 
[01:29:13.806]                               next
[01:29:13.806]                             invokeRestart(restart)
[01:29:13.806]                             muffled <- TRUE
[01:29:13.806]                             break
[01:29:13.806]                           }
[01:29:13.806]                         }
[01:29:13.806]                       }
[01:29:13.806]                       invisible(muffled)
[01:29:13.806]                     }
[01:29:13.806]                     muffleCondition(cond, pattern = "^muffle")
[01:29:13.806]                   }
[01:29:13.806]                 }
[01:29:13.806]                 else {
[01:29:13.806]                   if (TRUE) {
[01:29:13.806]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.806]                     {
[01:29:13.806]                       inherits <- base::inherits
[01:29:13.806]                       invokeRestart <- base::invokeRestart
[01:29:13.806]                       is.null <- base::is.null
[01:29:13.806]                       muffled <- FALSE
[01:29:13.806]                       if (inherits(cond, "message")) {
[01:29:13.806]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:13.806]                         if (muffled) 
[01:29:13.806]                           invokeRestart("muffleMessage")
[01:29:13.806]                       }
[01:29:13.806]                       else if (inherits(cond, "warning")) {
[01:29:13.806]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:13.806]                         if (muffled) 
[01:29:13.806]                           invokeRestart("muffleWarning")
[01:29:13.806]                       }
[01:29:13.806]                       else if (inherits(cond, "condition")) {
[01:29:13.806]                         if (!is.null(pattern)) {
[01:29:13.806]                           computeRestarts <- base::computeRestarts
[01:29:13.806]                           grepl <- base::grepl
[01:29:13.806]                           restarts <- computeRestarts(cond)
[01:29:13.806]                           for (restart in restarts) {
[01:29:13.806]                             name <- restart$name
[01:29:13.806]                             if (is.null(name)) 
[01:29:13.806]                               next
[01:29:13.806]                             if (!grepl(pattern, name)) 
[01:29:13.806]                               next
[01:29:13.806]                             invokeRestart(restart)
[01:29:13.806]                             muffled <- TRUE
[01:29:13.806]                             break
[01:29:13.806]                           }
[01:29:13.806]                         }
[01:29:13.806]                       }
[01:29:13.806]                       invisible(muffled)
[01:29:13.806]                     }
[01:29:13.806]                     muffleCondition(cond, pattern = "^muffle")
[01:29:13.806]                   }
[01:29:13.806]                 }
[01:29:13.806]             }
[01:29:13.806]         }))
[01:29:13.806]     }, error = function(ex) {
[01:29:13.806]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:13.806]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:13.806]                 ...future.rng), started = ...future.startTime, 
[01:29:13.806]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:13.806]             version = "1.8"), class = "FutureResult")
[01:29:13.806]     }, finally = {
[01:29:13.806]         if (!identical(...future.workdir, getwd())) 
[01:29:13.806]             setwd(...future.workdir)
[01:29:13.806]         {
[01:29:13.806]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:13.806]                 ...future.oldOptions$nwarnings <- NULL
[01:29:13.806]             }
[01:29:13.806]             base::options(...future.oldOptions)
[01:29:13.806]             if (.Platform$OS.type == "windows") {
[01:29:13.806]                 old_names <- names(...future.oldEnvVars)
[01:29:13.806]                 envs <- base::Sys.getenv()
[01:29:13.806]                 names <- names(envs)
[01:29:13.806]                 common <- intersect(names, old_names)
[01:29:13.806]                 added <- setdiff(names, old_names)
[01:29:13.806]                 removed <- setdiff(old_names, names)
[01:29:13.806]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:13.806]                   envs[common]]
[01:29:13.806]                 NAMES <- toupper(changed)
[01:29:13.806]                 args <- list()
[01:29:13.806]                 for (kk in seq_along(NAMES)) {
[01:29:13.806]                   name <- changed[[kk]]
[01:29:13.806]                   NAME <- NAMES[[kk]]
[01:29:13.806]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.806]                     next
[01:29:13.806]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:13.806]                 }
[01:29:13.806]                 NAMES <- toupper(added)
[01:29:13.806]                 for (kk in seq_along(NAMES)) {
[01:29:13.806]                   name <- added[[kk]]
[01:29:13.806]                   NAME <- NAMES[[kk]]
[01:29:13.806]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.806]                     next
[01:29:13.806]                   args[[name]] <- ""
[01:29:13.806]                 }
[01:29:13.806]                 NAMES <- toupper(removed)
[01:29:13.806]                 for (kk in seq_along(NAMES)) {
[01:29:13.806]                   name <- removed[[kk]]
[01:29:13.806]                   NAME <- NAMES[[kk]]
[01:29:13.806]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.806]                     next
[01:29:13.806]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:13.806]                 }
[01:29:13.806]                 if (length(args) > 0) 
[01:29:13.806]                   base::do.call(base::Sys.setenv, args = args)
[01:29:13.806]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:13.806]             }
[01:29:13.806]             else {
[01:29:13.806]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:13.806]             }
[01:29:13.806]             {
[01:29:13.806]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:13.806]                   0L) {
[01:29:13.806]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:13.806]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:13.806]                   base::options(opts)
[01:29:13.806]                 }
[01:29:13.806]                 {
[01:29:13.806]                   {
[01:29:13.806]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:13.806]                     NULL
[01:29:13.806]                   }
[01:29:13.806]                   options(future.plan = NULL)
[01:29:13.806]                   if (is.na(NA_character_)) 
[01:29:13.806]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:13.806]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:13.806]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:13.806]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:13.806]                     envir = parent.frame()) 
[01:29:13.806]                   {
[01:29:13.806]                     if (is.function(workers)) 
[01:29:13.806]                       workers <- workers()
[01:29:13.806]                     workers <- structure(as.integer(workers), 
[01:29:13.806]                       class = class(workers))
[01:29:13.806]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:13.806]                       workers >= 1)
[01:29:13.806]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:13.806]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:13.806]                     }
[01:29:13.806]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:13.806]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:13.806]                       envir = envir)
[01:29:13.806]                     if (!future$lazy) 
[01:29:13.806]                       future <- run(future)
[01:29:13.806]                     invisible(future)
[01:29:13.806]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:13.806]                 }
[01:29:13.806]             }
[01:29:13.806]         }
[01:29:13.806]     })
[01:29:13.806]     if (TRUE) {
[01:29:13.806]         base::sink(type = "output", split = FALSE)
[01:29:13.806]         if (TRUE) {
[01:29:13.806]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:13.806]         }
[01:29:13.806]         else {
[01:29:13.806]             ...future.result["stdout"] <- base::list(NULL)
[01:29:13.806]         }
[01:29:13.806]         base::close(...future.stdout)
[01:29:13.806]         ...future.stdout <- NULL
[01:29:13.806]     }
[01:29:13.806]     ...future.result$conditions <- ...future.conditions
[01:29:13.806]     ...future.result$finished <- base::Sys.time()
[01:29:13.806]     ...future.result
[01:29:13.806] }
[01:29:13.812] MultisessionFuture started
[01:29:13.812] - Launch lazy future ... done
[01:29:13.813] run() for 'MultisessionFuture' ... done
[01:29:13.813] resolve() on list environment ...
[01:29:13.814]  recursive: 0
[01:29:13.814]  length: 3
[01:29:13.815]  elements: 'a', 'b', 'c'
[01:29:13.815] receiveMessageFromWorker() for ClusterFuture ...
[01:29:13.815] - Validating connection of MultisessionFuture
[01:29:13.816] - received message: FutureResult
[01:29:13.816] - Received FutureResult
[01:29:13.816] - Erased future from FutureRegistry
[01:29:13.816] result() for ClusterFuture ...
[01:29:13.816] - result already collected: FutureResult
[01:29:13.816] result() for ClusterFuture ... done
[01:29:13.817] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:13.817] Future #1
[01:29:13.817]  length: 2 (resolved future 1)
[01:29:13.832] receiveMessageFromWorker() for ClusterFuture ...
[01:29:13.832] - Validating connection of MultisessionFuture
[01:29:13.833] - received message: FutureResult
[01:29:13.833] - Received FutureResult
[01:29:13.833] - Erased future from FutureRegistry
[01:29:13.834] result() for ClusterFuture ...
[01:29:13.834] - result already collected: FutureResult
[01:29:13.834] result() for ClusterFuture ... done
[01:29:13.834] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:13.834] Future #2
[01:29:13.835]  length: 1 (resolved future 2)
[01:29:13.835]  length: 0 (resolved future 3)
[01:29:13.835] resolve() on list environment ... DONE
[01:29:13.836] getGlobalsAndPackages() ...
[01:29:13.836] Searching for globals...
[01:29:13.837] - globals found: [1] '{'
[01:29:13.837] Searching for globals ... DONE
[01:29:13.837] Resolving globals: FALSE
[01:29:13.838] 
[01:29:13.838] 
[01:29:13.838] getGlobalsAndPackages() ... DONE
[01:29:13.838] run() for 'Future' ...
[01:29:13.838] - state: 'created'
[01:29:13.839] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:13.854] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:13.854] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:13.855]   - Field: 'node'
[01:29:13.855]   - Field: 'label'
[01:29:13.855]   - Field: 'local'
[01:29:13.855]   - Field: 'owner'
[01:29:13.855]   - Field: 'envir'
[01:29:13.855]   - Field: 'workers'
[01:29:13.856]   - Field: 'packages'
[01:29:13.856]   - Field: 'gc'
[01:29:13.856]   - Field: 'conditions'
[01:29:13.856]   - Field: 'persistent'
[01:29:13.856]   - Field: 'expr'
[01:29:13.857]   - Field: 'uuid'
[01:29:13.857]   - Field: 'seed'
[01:29:13.857]   - Field: 'version'
[01:29:13.857]   - Field: 'result'
[01:29:13.857]   - Field: 'asynchronous'
[01:29:13.857]   - Field: 'calls'
[01:29:13.858]   - Field: 'globals'
[01:29:13.858]   - Field: 'stdout'
[01:29:13.858]   - Field: 'earlySignal'
[01:29:13.858]   - Field: 'lazy'
[01:29:13.858]   - Field: 'state'
[01:29:13.859] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:13.859] - Launch lazy future ...
[01:29:13.859] Packages needed by the future expression (n = 0): <none>
[01:29:13.859] Packages needed by future strategies (n = 0): <none>
[01:29:13.860] {
[01:29:13.860]     {
[01:29:13.860]         {
[01:29:13.860]             ...future.startTime <- base::Sys.time()
[01:29:13.860]             {
[01:29:13.860]                 {
[01:29:13.860]                   {
[01:29:13.860]                     {
[01:29:13.860]                       base::local({
[01:29:13.860]                         has_future <- base::requireNamespace("future", 
[01:29:13.860]                           quietly = TRUE)
[01:29:13.860]                         if (has_future) {
[01:29:13.860]                           ns <- base::getNamespace("future")
[01:29:13.860]                           version <- ns[[".package"]][["version"]]
[01:29:13.860]                           if (is.null(version)) 
[01:29:13.860]                             version <- utils::packageVersion("future")
[01:29:13.860]                         }
[01:29:13.860]                         else {
[01:29:13.860]                           version <- NULL
[01:29:13.860]                         }
[01:29:13.860]                         if (!has_future || version < "1.8.0") {
[01:29:13.860]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:13.860]                             "", base::R.version$version.string), 
[01:29:13.860]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:13.860]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:13.860]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:13.860]                               "release", "version")], collapse = " "), 
[01:29:13.860]                             hostname = base::Sys.info()[["nodename"]])
[01:29:13.860]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:13.860]                             info)
[01:29:13.860]                           info <- base::paste(info, collapse = "; ")
[01:29:13.860]                           if (!has_future) {
[01:29:13.860]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:13.860]                               info)
[01:29:13.860]                           }
[01:29:13.860]                           else {
[01:29:13.860]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:13.860]                               info, version)
[01:29:13.860]                           }
[01:29:13.860]                           base::stop(msg)
[01:29:13.860]                         }
[01:29:13.860]                       })
[01:29:13.860]                     }
[01:29:13.860]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:13.860]                     base::options(mc.cores = 1L)
[01:29:13.860]                   }
[01:29:13.860]                   options(future.plan = NULL)
[01:29:13.860]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:13.860]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:13.860]                 }
[01:29:13.860]                 ...future.workdir <- getwd()
[01:29:13.860]             }
[01:29:13.860]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:13.860]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:13.860]         }
[01:29:13.860]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:13.860]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:13.860]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:13.860]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:13.860]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:13.860]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:13.860]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:13.860]             base::names(...future.oldOptions))
[01:29:13.860]     }
[01:29:13.860]     if (FALSE) {
[01:29:13.860]     }
[01:29:13.860]     else {
[01:29:13.860]         if (TRUE) {
[01:29:13.860]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:13.860]                 open = "w")
[01:29:13.860]         }
[01:29:13.860]         else {
[01:29:13.860]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:13.860]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:13.860]         }
[01:29:13.860]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:13.860]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:13.860]             base::sink(type = "output", split = FALSE)
[01:29:13.860]             base::close(...future.stdout)
[01:29:13.860]         }, add = TRUE)
[01:29:13.860]     }
[01:29:13.860]     ...future.frame <- base::sys.nframe()
[01:29:13.860]     ...future.conditions <- base::list()
[01:29:13.860]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:13.860]     if (FALSE) {
[01:29:13.860]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:13.860]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:13.860]     }
[01:29:13.860]     ...future.result <- base::tryCatch({
[01:29:13.860]         base::withCallingHandlers({
[01:29:13.860]             ...future.value <- base::withVisible(base::local({
[01:29:13.860]                 ...future.makeSendCondition <- base::local({
[01:29:13.860]                   sendCondition <- NULL
[01:29:13.860]                   function(frame = 1L) {
[01:29:13.860]                     if (is.function(sendCondition)) 
[01:29:13.860]                       return(sendCondition)
[01:29:13.860]                     ns <- getNamespace("parallel")
[01:29:13.860]                     if (exists("sendData", mode = "function", 
[01:29:13.860]                       envir = ns)) {
[01:29:13.860]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:13.860]                         envir = ns)
[01:29:13.860]                       envir <- sys.frame(frame)
[01:29:13.860]                       master <- NULL
[01:29:13.860]                       while (!identical(envir, .GlobalEnv) && 
[01:29:13.860]                         !identical(envir, emptyenv())) {
[01:29:13.860]                         if (exists("master", mode = "list", envir = envir, 
[01:29:13.860]                           inherits = FALSE)) {
[01:29:13.860]                           master <- get("master", mode = "list", 
[01:29:13.860]                             envir = envir, inherits = FALSE)
[01:29:13.860]                           if (inherits(master, c("SOCKnode", 
[01:29:13.860]                             "SOCK0node"))) {
[01:29:13.860]                             sendCondition <<- function(cond) {
[01:29:13.860]                               data <- list(type = "VALUE", value = cond, 
[01:29:13.860]                                 success = TRUE)
[01:29:13.860]                               parallel_sendData(master, data)
[01:29:13.860]                             }
[01:29:13.860]                             return(sendCondition)
[01:29:13.860]                           }
[01:29:13.860]                         }
[01:29:13.860]                         frame <- frame + 1L
[01:29:13.860]                         envir <- sys.frame(frame)
[01:29:13.860]                       }
[01:29:13.860]                     }
[01:29:13.860]                     sendCondition <<- function(cond) NULL
[01:29:13.860]                   }
[01:29:13.860]                 })
[01:29:13.860]                 withCallingHandlers({
[01:29:13.860]                   {
[01:29:13.860]                     1
[01:29:13.860]                   }
[01:29:13.860]                 }, immediateCondition = function(cond) {
[01:29:13.860]                   sendCondition <- ...future.makeSendCondition()
[01:29:13.860]                   sendCondition(cond)
[01:29:13.860]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.860]                   {
[01:29:13.860]                     inherits <- base::inherits
[01:29:13.860]                     invokeRestart <- base::invokeRestart
[01:29:13.860]                     is.null <- base::is.null
[01:29:13.860]                     muffled <- FALSE
[01:29:13.860]                     if (inherits(cond, "message")) {
[01:29:13.860]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:13.860]                       if (muffled) 
[01:29:13.860]                         invokeRestart("muffleMessage")
[01:29:13.860]                     }
[01:29:13.860]                     else if (inherits(cond, "warning")) {
[01:29:13.860]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:13.860]                       if (muffled) 
[01:29:13.860]                         invokeRestart("muffleWarning")
[01:29:13.860]                     }
[01:29:13.860]                     else if (inherits(cond, "condition")) {
[01:29:13.860]                       if (!is.null(pattern)) {
[01:29:13.860]                         computeRestarts <- base::computeRestarts
[01:29:13.860]                         grepl <- base::grepl
[01:29:13.860]                         restarts <- computeRestarts(cond)
[01:29:13.860]                         for (restart in restarts) {
[01:29:13.860]                           name <- restart$name
[01:29:13.860]                           if (is.null(name)) 
[01:29:13.860]                             next
[01:29:13.860]                           if (!grepl(pattern, name)) 
[01:29:13.860]                             next
[01:29:13.860]                           invokeRestart(restart)
[01:29:13.860]                           muffled <- TRUE
[01:29:13.860]                           break
[01:29:13.860]                         }
[01:29:13.860]                       }
[01:29:13.860]                     }
[01:29:13.860]                     invisible(muffled)
[01:29:13.860]                   }
[01:29:13.860]                   muffleCondition(cond)
[01:29:13.860]                 })
[01:29:13.860]             }))
[01:29:13.860]             future::FutureResult(value = ...future.value$value, 
[01:29:13.860]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:13.860]                   ...future.rng), globalenv = if (FALSE) 
[01:29:13.860]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:13.860]                     ...future.globalenv.names))
[01:29:13.860]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:13.860]         }, condition = base::local({
[01:29:13.860]             c <- base::c
[01:29:13.860]             inherits <- base::inherits
[01:29:13.860]             invokeRestart <- base::invokeRestart
[01:29:13.860]             length <- base::length
[01:29:13.860]             list <- base::list
[01:29:13.860]             seq.int <- base::seq.int
[01:29:13.860]             signalCondition <- base::signalCondition
[01:29:13.860]             sys.calls <- base::sys.calls
[01:29:13.860]             `[[` <- base::`[[`
[01:29:13.860]             `+` <- base::`+`
[01:29:13.860]             `<<-` <- base::`<<-`
[01:29:13.860]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:13.860]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:13.860]                   3L)]
[01:29:13.860]             }
[01:29:13.860]             function(cond) {
[01:29:13.860]                 is_error <- inherits(cond, "error")
[01:29:13.860]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:13.860]                   NULL)
[01:29:13.860]                 if (is_error) {
[01:29:13.860]                   sessionInformation <- function() {
[01:29:13.860]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:13.860]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:13.860]                       search = base::search(), system = base::Sys.info())
[01:29:13.860]                   }
[01:29:13.860]                   ...future.conditions[[length(...future.conditions) + 
[01:29:13.860]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:13.860]                     cond$call), session = sessionInformation(), 
[01:29:13.860]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:13.860]                   signalCondition(cond)
[01:29:13.860]                 }
[01:29:13.860]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:13.860]                 "immediateCondition"))) {
[01:29:13.860]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:13.860]                   ...future.conditions[[length(...future.conditions) + 
[01:29:13.860]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:13.860]                   if (TRUE && !signal) {
[01:29:13.860]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.860]                     {
[01:29:13.860]                       inherits <- base::inherits
[01:29:13.860]                       invokeRestart <- base::invokeRestart
[01:29:13.860]                       is.null <- base::is.null
[01:29:13.860]                       muffled <- FALSE
[01:29:13.860]                       if (inherits(cond, "message")) {
[01:29:13.860]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:13.860]                         if (muffled) 
[01:29:13.860]                           invokeRestart("muffleMessage")
[01:29:13.860]                       }
[01:29:13.860]                       else if (inherits(cond, "warning")) {
[01:29:13.860]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:13.860]                         if (muffled) 
[01:29:13.860]                           invokeRestart("muffleWarning")
[01:29:13.860]                       }
[01:29:13.860]                       else if (inherits(cond, "condition")) {
[01:29:13.860]                         if (!is.null(pattern)) {
[01:29:13.860]                           computeRestarts <- base::computeRestarts
[01:29:13.860]                           grepl <- base::grepl
[01:29:13.860]                           restarts <- computeRestarts(cond)
[01:29:13.860]                           for (restart in restarts) {
[01:29:13.860]                             name <- restart$name
[01:29:13.860]                             if (is.null(name)) 
[01:29:13.860]                               next
[01:29:13.860]                             if (!grepl(pattern, name)) 
[01:29:13.860]                               next
[01:29:13.860]                             invokeRestart(restart)
[01:29:13.860]                             muffled <- TRUE
[01:29:13.860]                             break
[01:29:13.860]                           }
[01:29:13.860]                         }
[01:29:13.860]                       }
[01:29:13.860]                       invisible(muffled)
[01:29:13.860]                     }
[01:29:13.860]                     muffleCondition(cond, pattern = "^muffle")
[01:29:13.860]                   }
[01:29:13.860]                 }
[01:29:13.860]                 else {
[01:29:13.860]                   if (TRUE) {
[01:29:13.860]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.860]                     {
[01:29:13.860]                       inherits <- base::inherits
[01:29:13.860]                       invokeRestart <- base::invokeRestart
[01:29:13.860]                       is.null <- base::is.null
[01:29:13.860]                       muffled <- FALSE
[01:29:13.860]                       if (inherits(cond, "message")) {
[01:29:13.860]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:13.860]                         if (muffled) 
[01:29:13.860]                           invokeRestart("muffleMessage")
[01:29:13.860]                       }
[01:29:13.860]                       else if (inherits(cond, "warning")) {
[01:29:13.860]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:13.860]                         if (muffled) 
[01:29:13.860]                           invokeRestart("muffleWarning")
[01:29:13.860]                       }
[01:29:13.860]                       else if (inherits(cond, "condition")) {
[01:29:13.860]                         if (!is.null(pattern)) {
[01:29:13.860]                           computeRestarts <- base::computeRestarts
[01:29:13.860]                           grepl <- base::grepl
[01:29:13.860]                           restarts <- computeRestarts(cond)
[01:29:13.860]                           for (restart in restarts) {
[01:29:13.860]                             name <- restart$name
[01:29:13.860]                             if (is.null(name)) 
[01:29:13.860]                               next
[01:29:13.860]                             if (!grepl(pattern, name)) 
[01:29:13.860]                               next
[01:29:13.860]                             invokeRestart(restart)
[01:29:13.860]                             muffled <- TRUE
[01:29:13.860]                             break
[01:29:13.860]                           }
[01:29:13.860]                         }
[01:29:13.860]                       }
[01:29:13.860]                       invisible(muffled)
[01:29:13.860]                     }
[01:29:13.860]                     muffleCondition(cond, pattern = "^muffle")
[01:29:13.860]                   }
[01:29:13.860]                 }
[01:29:13.860]             }
[01:29:13.860]         }))
[01:29:13.860]     }, error = function(ex) {
[01:29:13.860]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:13.860]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:13.860]                 ...future.rng), started = ...future.startTime, 
[01:29:13.860]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:13.860]             version = "1.8"), class = "FutureResult")
[01:29:13.860]     }, finally = {
[01:29:13.860]         if (!identical(...future.workdir, getwd())) 
[01:29:13.860]             setwd(...future.workdir)
[01:29:13.860]         {
[01:29:13.860]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:13.860]                 ...future.oldOptions$nwarnings <- NULL
[01:29:13.860]             }
[01:29:13.860]             base::options(...future.oldOptions)
[01:29:13.860]             if (.Platform$OS.type == "windows") {
[01:29:13.860]                 old_names <- names(...future.oldEnvVars)
[01:29:13.860]                 envs <- base::Sys.getenv()
[01:29:13.860]                 names <- names(envs)
[01:29:13.860]                 common <- intersect(names, old_names)
[01:29:13.860]                 added <- setdiff(names, old_names)
[01:29:13.860]                 removed <- setdiff(old_names, names)
[01:29:13.860]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:13.860]                   envs[common]]
[01:29:13.860]                 NAMES <- toupper(changed)
[01:29:13.860]                 args <- list()
[01:29:13.860]                 for (kk in seq_along(NAMES)) {
[01:29:13.860]                   name <- changed[[kk]]
[01:29:13.860]                   NAME <- NAMES[[kk]]
[01:29:13.860]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.860]                     next
[01:29:13.860]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:13.860]                 }
[01:29:13.860]                 NAMES <- toupper(added)
[01:29:13.860]                 for (kk in seq_along(NAMES)) {
[01:29:13.860]                   name <- added[[kk]]
[01:29:13.860]                   NAME <- NAMES[[kk]]
[01:29:13.860]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.860]                     next
[01:29:13.860]                   args[[name]] <- ""
[01:29:13.860]                 }
[01:29:13.860]                 NAMES <- toupper(removed)
[01:29:13.860]                 for (kk in seq_along(NAMES)) {
[01:29:13.860]                   name <- removed[[kk]]
[01:29:13.860]                   NAME <- NAMES[[kk]]
[01:29:13.860]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.860]                     next
[01:29:13.860]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:13.860]                 }
[01:29:13.860]                 if (length(args) > 0) 
[01:29:13.860]                   base::do.call(base::Sys.setenv, args = args)
[01:29:13.860]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:13.860]             }
[01:29:13.860]             else {
[01:29:13.860]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:13.860]             }
[01:29:13.860]             {
[01:29:13.860]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:13.860]                   0L) {
[01:29:13.860]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:13.860]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:13.860]                   base::options(opts)
[01:29:13.860]                 }
[01:29:13.860]                 {
[01:29:13.860]                   {
[01:29:13.860]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:13.860]                     NULL
[01:29:13.860]                   }
[01:29:13.860]                   options(future.plan = NULL)
[01:29:13.860]                   if (is.na(NA_character_)) 
[01:29:13.860]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:13.860]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:13.860]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:13.860]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:13.860]                     envir = parent.frame()) 
[01:29:13.860]                   {
[01:29:13.860]                     if (is.function(workers)) 
[01:29:13.860]                       workers <- workers()
[01:29:13.860]                     workers <- structure(as.integer(workers), 
[01:29:13.860]                       class = class(workers))
[01:29:13.860]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:13.860]                       workers >= 1)
[01:29:13.860]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:13.860]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:13.860]                     }
[01:29:13.860]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:13.860]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:13.860]                       envir = envir)
[01:29:13.860]                     if (!future$lazy) 
[01:29:13.860]                       future <- run(future)
[01:29:13.860]                     invisible(future)
[01:29:13.860]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:13.860]                 }
[01:29:13.860]             }
[01:29:13.860]         }
[01:29:13.860]     })
[01:29:13.860]     if (TRUE) {
[01:29:13.860]         base::sink(type = "output", split = FALSE)
[01:29:13.860]         if (TRUE) {
[01:29:13.860]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:13.860]         }
[01:29:13.860]         else {
[01:29:13.860]             ...future.result["stdout"] <- base::list(NULL)
[01:29:13.860]         }
[01:29:13.860]         base::close(...future.stdout)
[01:29:13.860]         ...future.stdout <- NULL
[01:29:13.860]     }
[01:29:13.860]     ...future.result$conditions <- ...future.conditions
[01:29:13.860]     ...future.result$finished <- base::Sys.time()
[01:29:13.860]     ...future.result
[01:29:13.860] }
[01:29:13.866] MultisessionFuture started
[01:29:13.867] - Launch lazy future ... done
[01:29:13.867] run() for 'MultisessionFuture' ... done
[01:29:13.867] getGlobalsAndPackages() ...
[01:29:13.868] Searching for globals...
[01:29:13.869] - globals found: [2] '{', 'Sys.sleep'
[01:29:13.869] Searching for globals ... DONE
[01:29:13.869] Resolving globals: FALSE
[01:29:13.870] 
[01:29:13.870] 
[01:29:13.870] getGlobalsAndPackages() ... DONE
[01:29:13.871] run() for 'Future' ...
[01:29:13.871] - state: 'created'
[01:29:13.871] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:13.886] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:13.886] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:13.886]   - Field: 'node'
[01:29:13.886]   - Field: 'label'
[01:29:13.887]   - Field: 'local'
[01:29:13.887]   - Field: 'owner'
[01:29:13.887]   - Field: 'envir'
[01:29:13.887]   - Field: 'workers'
[01:29:13.887]   - Field: 'packages'
[01:29:13.888]   - Field: 'gc'
[01:29:13.888]   - Field: 'conditions'
[01:29:13.888]   - Field: 'persistent'
[01:29:13.888]   - Field: 'expr'
[01:29:13.888]   - Field: 'uuid'
[01:29:13.889]   - Field: 'seed'
[01:29:13.889]   - Field: 'version'
[01:29:13.889]   - Field: 'result'
[01:29:13.889]   - Field: 'asynchronous'
[01:29:13.889]   - Field: 'calls'
[01:29:13.890]   - Field: 'globals'
[01:29:13.890]   - Field: 'stdout'
[01:29:13.890]   - Field: 'earlySignal'
[01:29:13.890]   - Field: 'lazy'
[01:29:13.890]   - Field: 'state'
[01:29:13.891] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:13.891] - Launch lazy future ...
[01:29:13.891] Packages needed by the future expression (n = 0): <none>
[01:29:13.891] Packages needed by future strategies (n = 0): <none>
[01:29:13.892] {
[01:29:13.892]     {
[01:29:13.892]         {
[01:29:13.892]             ...future.startTime <- base::Sys.time()
[01:29:13.892]             {
[01:29:13.892]                 {
[01:29:13.892]                   {
[01:29:13.892]                     {
[01:29:13.892]                       base::local({
[01:29:13.892]                         has_future <- base::requireNamespace("future", 
[01:29:13.892]                           quietly = TRUE)
[01:29:13.892]                         if (has_future) {
[01:29:13.892]                           ns <- base::getNamespace("future")
[01:29:13.892]                           version <- ns[[".package"]][["version"]]
[01:29:13.892]                           if (is.null(version)) 
[01:29:13.892]                             version <- utils::packageVersion("future")
[01:29:13.892]                         }
[01:29:13.892]                         else {
[01:29:13.892]                           version <- NULL
[01:29:13.892]                         }
[01:29:13.892]                         if (!has_future || version < "1.8.0") {
[01:29:13.892]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:13.892]                             "", base::R.version$version.string), 
[01:29:13.892]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:13.892]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:13.892]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:13.892]                               "release", "version")], collapse = " "), 
[01:29:13.892]                             hostname = base::Sys.info()[["nodename"]])
[01:29:13.892]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:13.892]                             info)
[01:29:13.892]                           info <- base::paste(info, collapse = "; ")
[01:29:13.892]                           if (!has_future) {
[01:29:13.892]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:13.892]                               info)
[01:29:13.892]                           }
[01:29:13.892]                           else {
[01:29:13.892]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:13.892]                               info, version)
[01:29:13.892]                           }
[01:29:13.892]                           base::stop(msg)
[01:29:13.892]                         }
[01:29:13.892]                       })
[01:29:13.892]                     }
[01:29:13.892]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:13.892]                     base::options(mc.cores = 1L)
[01:29:13.892]                   }
[01:29:13.892]                   options(future.plan = NULL)
[01:29:13.892]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:13.892]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:13.892]                 }
[01:29:13.892]                 ...future.workdir <- getwd()
[01:29:13.892]             }
[01:29:13.892]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:13.892]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:13.892]         }
[01:29:13.892]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:13.892]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:13.892]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:13.892]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:13.892]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:13.892]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:13.892]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:13.892]             base::names(...future.oldOptions))
[01:29:13.892]     }
[01:29:13.892]     if (FALSE) {
[01:29:13.892]     }
[01:29:13.892]     else {
[01:29:13.892]         if (TRUE) {
[01:29:13.892]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:13.892]                 open = "w")
[01:29:13.892]         }
[01:29:13.892]         else {
[01:29:13.892]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:13.892]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:13.892]         }
[01:29:13.892]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:13.892]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:13.892]             base::sink(type = "output", split = FALSE)
[01:29:13.892]             base::close(...future.stdout)
[01:29:13.892]         }, add = TRUE)
[01:29:13.892]     }
[01:29:13.892]     ...future.frame <- base::sys.nframe()
[01:29:13.892]     ...future.conditions <- base::list()
[01:29:13.892]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:13.892]     if (FALSE) {
[01:29:13.892]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:13.892]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:13.892]     }
[01:29:13.892]     ...future.result <- base::tryCatch({
[01:29:13.892]         base::withCallingHandlers({
[01:29:13.892]             ...future.value <- base::withVisible(base::local({
[01:29:13.892]                 ...future.makeSendCondition <- base::local({
[01:29:13.892]                   sendCondition <- NULL
[01:29:13.892]                   function(frame = 1L) {
[01:29:13.892]                     if (is.function(sendCondition)) 
[01:29:13.892]                       return(sendCondition)
[01:29:13.892]                     ns <- getNamespace("parallel")
[01:29:13.892]                     if (exists("sendData", mode = "function", 
[01:29:13.892]                       envir = ns)) {
[01:29:13.892]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:13.892]                         envir = ns)
[01:29:13.892]                       envir <- sys.frame(frame)
[01:29:13.892]                       master <- NULL
[01:29:13.892]                       while (!identical(envir, .GlobalEnv) && 
[01:29:13.892]                         !identical(envir, emptyenv())) {
[01:29:13.892]                         if (exists("master", mode = "list", envir = envir, 
[01:29:13.892]                           inherits = FALSE)) {
[01:29:13.892]                           master <- get("master", mode = "list", 
[01:29:13.892]                             envir = envir, inherits = FALSE)
[01:29:13.892]                           if (inherits(master, c("SOCKnode", 
[01:29:13.892]                             "SOCK0node"))) {
[01:29:13.892]                             sendCondition <<- function(cond) {
[01:29:13.892]                               data <- list(type = "VALUE", value = cond, 
[01:29:13.892]                                 success = TRUE)
[01:29:13.892]                               parallel_sendData(master, data)
[01:29:13.892]                             }
[01:29:13.892]                             return(sendCondition)
[01:29:13.892]                           }
[01:29:13.892]                         }
[01:29:13.892]                         frame <- frame + 1L
[01:29:13.892]                         envir <- sys.frame(frame)
[01:29:13.892]                       }
[01:29:13.892]                     }
[01:29:13.892]                     sendCondition <<- function(cond) NULL
[01:29:13.892]                   }
[01:29:13.892]                 })
[01:29:13.892]                 withCallingHandlers({
[01:29:13.892]                   {
[01:29:13.892]                     Sys.sleep(0.5)
[01:29:13.892]                     2
[01:29:13.892]                   }
[01:29:13.892]                 }, immediateCondition = function(cond) {
[01:29:13.892]                   sendCondition <- ...future.makeSendCondition()
[01:29:13.892]                   sendCondition(cond)
[01:29:13.892]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.892]                   {
[01:29:13.892]                     inherits <- base::inherits
[01:29:13.892]                     invokeRestart <- base::invokeRestart
[01:29:13.892]                     is.null <- base::is.null
[01:29:13.892]                     muffled <- FALSE
[01:29:13.892]                     if (inherits(cond, "message")) {
[01:29:13.892]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:13.892]                       if (muffled) 
[01:29:13.892]                         invokeRestart("muffleMessage")
[01:29:13.892]                     }
[01:29:13.892]                     else if (inherits(cond, "warning")) {
[01:29:13.892]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:13.892]                       if (muffled) 
[01:29:13.892]                         invokeRestart("muffleWarning")
[01:29:13.892]                     }
[01:29:13.892]                     else if (inherits(cond, "condition")) {
[01:29:13.892]                       if (!is.null(pattern)) {
[01:29:13.892]                         computeRestarts <- base::computeRestarts
[01:29:13.892]                         grepl <- base::grepl
[01:29:13.892]                         restarts <- computeRestarts(cond)
[01:29:13.892]                         for (restart in restarts) {
[01:29:13.892]                           name <- restart$name
[01:29:13.892]                           if (is.null(name)) 
[01:29:13.892]                             next
[01:29:13.892]                           if (!grepl(pattern, name)) 
[01:29:13.892]                             next
[01:29:13.892]                           invokeRestart(restart)
[01:29:13.892]                           muffled <- TRUE
[01:29:13.892]                           break
[01:29:13.892]                         }
[01:29:13.892]                       }
[01:29:13.892]                     }
[01:29:13.892]                     invisible(muffled)
[01:29:13.892]                   }
[01:29:13.892]                   muffleCondition(cond)
[01:29:13.892]                 })
[01:29:13.892]             }))
[01:29:13.892]             future::FutureResult(value = ...future.value$value, 
[01:29:13.892]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:13.892]                   ...future.rng), globalenv = if (FALSE) 
[01:29:13.892]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:13.892]                     ...future.globalenv.names))
[01:29:13.892]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:13.892]         }, condition = base::local({
[01:29:13.892]             c <- base::c
[01:29:13.892]             inherits <- base::inherits
[01:29:13.892]             invokeRestart <- base::invokeRestart
[01:29:13.892]             length <- base::length
[01:29:13.892]             list <- base::list
[01:29:13.892]             seq.int <- base::seq.int
[01:29:13.892]             signalCondition <- base::signalCondition
[01:29:13.892]             sys.calls <- base::sys.calls
[01:29:13.892]             `[[` <- base::`[[`
[01:29:13.892]             `+` <- base::`+`
[01:29:13.892]             `<<-` <- base::`<<-`
[01:29:13.892]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:13.892]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:13.892]                   3L)]
[01:29:13.892]             }
[01:29:13.892]             function(cond) {
[01:29:13.892]                 is_error <- inherits(cond, "error")
[01:29:13.892]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:13.892]                   NULL)
[01:29:13.892]                 if (is_error) {
[01:29:13.892]                   sessionInformation <- function() {
[01:29:13.892]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:13.892]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:13.892]                       search = base::search(), system = base::Sys.info())
[01:29:13.892]                   }
[01:29:13.892]                   ...future.conditions[[length(...future.conditions) + 
[01:29:13.892]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:13.892]                     cond$call), session = sessionInformation(), 
[01:29:13.892]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:13.892]                   signalCondition(cond)
[01:29:13.892]                 }
[01:29:13.892]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:13.892]                 "immediateCondition"))) {
[01:29:13.892]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:13.892]                   ...future.conditions[[length(...future.conditions) + 
[01:29:13.892]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:13.892]                   if (TRUE && !signal) {
[01:29:13.892]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.892]                     {
[01:29:13.892]                       inherits <- base::inherits
[01:29:13.892]                       invokeRestart <- base::invokeRestart
[01:29:13.892]                       is.null <- base::is.null
[01:29:13.892]                       muffled <- FALSE
[01:29:13.892]                       if (inherits(cond, "message")) {
[01:29:13.892]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:13.892]                         if (muffled) 
[01:29:13.892]                           invokeRestart("muffleMessage")
[01:29:13.892]                       }
[01:29:13.892]                       else if (inherits(cond, "warning")) {
[01:29:13.892]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:13.892]                         if (muffled) 
[01:29:13.892]                           invokeRestart("muffleWarning")
[01:29:13.892]                       }
[01:29:13.892]                       else if (inherits(cond, "condition")) {
[01:29:13.892]                         if (!is.null(pattern)) {
[01:29:13.892]                           computeRestarts <- base::computeRestarts
[01:29:13.892]                           grepl <- base::grepl
[01:29:13.892]                           restarts <- computeRestarts(cond)
[01:29:13.892]                           for (restart in restarts) {
[01:29:13.892]                             name <- restart$name
[01:29:13.892]                             if (is.null(name)) 
[01:29:13.892]                               next
[01:29:13.892]                             if (!grepl(pattern, name)) 
[01:29:13.892]                               next
[01:29:13.892]                             invokeRestart(restart)
[01:29:13.892]                             muffled <- TRUE
[01:29:13.892]                             break
[01:29:13.892]                           }
[01:29:13.892]                         }
[01:29:13.892]                       }
[01:29:13.892]                       invisible(muffled)
[01:29:13.892]                     }
[01:29:13.892]                     muffleCondition(cond, pattern = "^muffle")
[01:29:13.892]                   }
[01:29:13.892]                 }
[01:29:13.892]                 else {
[01:29:13.892]                   if (TRUE) {
[01:29:13.892]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.892]                     {
[01:29:13.892]                       inherits <- base::inherits
[01:29:13.892]                       invokeRestart <- base::invokeRestart
[01:29:13.892]                       is.null <- base::is.null
[01:29:13.892]                       muffled <- FALSE
[01:29:13.892]                       if (inherits(cond, "message")) {
[01:29:13.892]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:13.892]                         if (muffled) 
[01:29:13.892]                           invokeRestart("muffleMessage")
[01:29:13.892]                       }
[01:29:13.892]                       else if (inherits(cond, "warning")) {
[01:29:13.892]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:13.892]                         if (muffled) 
[01:29:13.892]                           invokeRestart("muffleWarning")
[01:29:13.892]                       }
[01:29:13.892]                       else if (inherits(cond, "condition")) {
[01:29:13.892]                         if (!is.null(pattern)) {
[01:29:13.892]                           computeRestarts <- base::computeRestarts
[01:29:13.892]                           grepl <- base::grepl
[01:29:13.892]                           restarts <- computeRestarts(cond)
[01:29:13.892]                           for (restart in restarts) {
[01:29:13.892]                             name <- restart$name
[01:29:13.892]                             if (is.null(name)) 
[01:29:13.892]                               next
[01:29:13.892]                             if (!grepl(pattern, name)) 
[01:29:13.892]                               next
[01:29:13.892]                             invokeRestart(restart)
[01:29:13.892]                             muffled <- TRUE
[01:29:13.892]                             break
[01:29:13.892]                           }
[01:29:13.892]                         }
[01:29:13.892]                       }
[01:29:13.892]                       invisible(muffled)
[01:29:13.892]                     }
[01:29:13.892]                     muffleCondition(cond, pattern = "^muffle")
[01:29:13.892]                   }
[01:29:13.892]                 }
[01:29:13.892]             }
[01:29:13.892]         }))
[01:29:13.892]     }, error = function(ex) {
[01:29:13.892]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:13.892]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:13.892]                 ...future.rng), started = ...future.startTime, 
[01:29:13.892]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:13.892]             version = "1.8"), class = "FutureResult")
[01:29:13.892]     }, finally = {
[01:29:13.892]         if (!identical(...future.workdir, getwd())) 
[01:29:13.892]             setwd(...future.workdir)
[01:29:13.892]         {
[01:29:13.892]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:13.892]                 ...future.oldOptions$nwarnings <- NULL
[01:29:13.892]             }
[01:29:13.892]             base::options(...future.oldOptions)
[01:29:13.892]             if (.Platform$OS.type == "windows") {
[01:29:13.892]                 old_names <- names(...future.oldEnvVars)
[01:29:13.892]                 envs <- base::Sys.getenv()
[01:29:13.892]                 names <- names(envs)
[01:29:13.892]                 common <- intersect(names, old_names)
[01:29:13.892]                 added <- setdiff(names, old_names)
[01:29:13.892]                 removed <- setdiff(old_names, names)
[01:29:13.892]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:13.892]                   envs[common]]
[01:29:13.892]                 NAMES <- toupper(changed)
[01:29:13.892]                 args <- list()
[01:29:13.892]                 for (kk in seq_along(NAMES)) {
[01:29:13.892]                   name <- changed[[kk]]
[01:29:13.892]                   NAME <- NAMES[[kk]]
[01:29:13.892]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.892]                     next
[01:29:13.892]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:13.892]                 }
[01:29:13.892]                 NAMES <- toupper(added)
[01:29:13.892]                 for (kk in seq_along(NAMES)) {
[01:29:13.892]                   name <- added[[kk]]
[01:29:13.892]                   NAME <- NAMES[[kk]]
[01:29:13.892]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.892]                     next
[01:29:13.892]                   args[[name]] <- ""
[01:29:13.892]                 }
[01:29:13.892]                 NAMES <- toupper(removed)
[01:29:13.892]                 for (kk in seq_along(NAMES)) {
[01:29:13.892]                   name <- removed[[kk]]
[01:29:13.892]                   NAME <- NAMES[[kk]]
[01:29:13.892]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.892]                     next
[01:29:13.892]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:13.892]                 }
[01:29:13.892]                 if (length(args) > 0) 
[01:29:13.892]                   base::do.call(base::Sys.setenv, args = args)
[01:29:13.892]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:13.892]             }
[01:29:13.892]             else {
[01:29:13.892]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:13.892]             }
[01:29:13.892]             {
[01:29:13.892]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:13.892]                   0L) {
[01:29:13.892]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:13.892]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:13.892]                   base::options(opts)
[01:29:13.892]                 }
[01:29:13.892]                 {
[01:29:13.892]                   {
[01:29:13.892]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:13.892]                     NULL
[01:29:13.892]                   }
[01:29:13.892]                   options(future.plan = NULL)
[01:29:13.892]                   if (is.na(NA_character_)) 
[01:29:13.892]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:13.892]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:13.892]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:13.892]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:13.892]                     envir = parent.frame()) 
[01:29:13.892]                   {
[01:29:13.892]                     if (is.function(workers)) 
[01:29:13.892]                       workers <- workers()
[01:29:13.892]                     workers <- structure(as.integer(workers), 
[01:29:13.892]                       class = class(workers))
[01:29:13.892]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:13.892]                       workers >= 1)
[01:29:13.892]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:13.892]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:13.892]                     }
[01:29:13.892]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:13.892]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:13.892]                       envir = envir)
[01:29:13.892]                     if (!future$lazy) 
[01:29:13.892]                       future <- run(future)
[01:29:13.892]                     invisible(future)
[01:29:13.892]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:13.892]                 }
[01:29:13.892]             }
[01:29:13.892]         }
[01:29:13.892]     })
[01:29:13.892]     if (TRUE) {
[01:29:13.892]         base::sink(type = "output", split = FALSE)
[01:29:13.892]         if (TRUE) {
[01:29:13.892]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:13.892]         }
[01:29:13.892]         else {
[01:29:13.892]             ...future.result["stdout"] <- base::list(NULL)
[01:29:13.892]         }
[01:29:13.892]         base::close(...future.stdout)
[01:29:13.892]         ...future.stdout <- NULL
[01:29:13.892]     }
[01:29:13.892]     ...future.result$conditions <- ...future.conditions
[01:29:13.892]     ...future.result$finished <- base::Sys.time()
[01:29:13.892]     ...future.result
[01:29:13.892] }
[01:29:13.898] MultisessionFuture started
[01:29:13.898] - Launch lazy future ... done
[01:29:13.898] run() for 'MultisessionFuture' ... done
[01:29:13.899] getGlobalsAndPackages() ...
[01:29:13.899] Searching for globals...
[01:29:13.900] - globals found: [1] '{'
[01:29:13.900] Searching for globals ... DONE
[01:29:13.900] Resolving globals: FALSE
[01:29:13.901] 
[01:29:13.901] 
[01:29:13.901] getGlobalsAndPackages() ... DONE
[01:29:13.901] run() for 'Future' ...
[01:29:13.902] - state: 'created'
[01:29:13.902] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:13.916] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:13.916] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:13.916]   - Field: 'node'
[01:29:13.917]   - Field: 'label'
[01:29:13.917]   - Field: 'local'
[01:29:13.917]   - Field: 'owner'
[01:29:13.917]   - Field: 'envir'
[01:29:13.917]   - Field: 'workers'
[01:29:13.918]   - Field: 'packages'
[01:29:13.918]   - Field: 'gc'
[01:29:13.918]   - Field: 'conditions'
[01:29:13.918]   - Field: 'persistent'
[01:29:13.918]   - Field: 'expr'
[01:29:13.918]   - Field: 'uuid'
[01:29:13.919]   - Field: 'seed'
[01:29:13.919]   - Field: 'version'
[01:29:13.919]   - Field: 'result'
[01:29:13.919]   - Field: 'asynchronous'
[01:29:13.919]   - Field: 'calls'
[01:29:13.920]   - Field: 'globals'
[01:29:13.920]   - Field: 'stdout'
[01:29:13.920]   - Field: 'earlySignal'
[01:29:13.920]   - Field: 'lazy'
[01:29:13.920]   - Field: 'state'
[01:29:13.920] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:13.921] - Launch lazy future ...
[01:29:13.921] Packages needed by the future expression (n = 0): <none>
[01:29:13.921] Packages needed by future strategies (n = 0): <none>
[01:29:13.922] {
[01:29:13.922]     {
[01:29:13.922]         {
[01:29:13.922]             ...future.startTime <- base::Sys.time()
[01:29:13.922]             {
[01:29:13.922]                 {
[01:29:13.922]                   {
[01:29:13.922]                     {
[01:29:13.922]                       base::local({
[01:29:13.922]                         has_future <- base::requireNamespace("future", 
[01:29:13.922]                           quietly = TRUE)
[01:29:13.922]                         if (has_future) {
[01:29:13.922]                           ns <- base::getNamespace("future")
[01:29:13.922]                           version <- ns[[".package"]][["version"]]
[01:29:13.922]                           if (is.null(version)) 
[01:29:13.922]                             version <- utils::packageVersion("future")
[01:29:13.922]                         }
[01:29:13.922]                         else {
[01:29:13.922]                           version <- NULL
[01:29:13.922]                         }
[01:29:13.922]                         if (!has_future || version < "1.8.0") {
[01:29:13.922]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:13.922]                             "", base::R.version$version.string), 
[01:29:13.922]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:13.922]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:13.922]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:13.922]                               "release", "version")], collapse = " "), 
[01:29:13.922]                             hostname = base::Sys.info()[["nodename"]])
[01:29:13.922]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:13.922]                             info)
[01:29:13.922]                           info <- base::paste(info, collapse = "; ")
[01:29:13.922]                           if (!has_future) {
[01:29:13.922]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:13.922]                               info)
[01:29:13.922]                           }
[01:29:13.922]                           else {
[01:29:13.922]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:13.922]                               info, version)
[01:29:13.922]                           }
[01:29:13.922]                           base::stop(msg)
[01:29:13.922]                         }
[01:29:13.922]                       })
[01:29:13.922]                     }
[01:29:13.922]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:13.922]                     base::options(mc.cores = 1L)
[01:29:13.922]                   }
[01:29:13.922]                   options(future.plan = NULL)
[01:29:13.922]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:13.922]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:13.922]                 }
[01:29:13.922]                 ...future.workdir <- getwd()
[01:29:13.922]             }
[01:29:13.922]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:13.922]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:13.922]         }
[01:29:13.922]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:13.922]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:13.922]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:13.922]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:13.922]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:13.922]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:13.922]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:13.922]             base::names(...future.oldOptions))
[01:29:13.922]     }
[01:29:13.922]     if (FALSE) {
[01:29:13.922]     }
[01:29:13.922]     else {
[01:29:13.922]         if (TRUE) {
[01:29:13.922]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:13.922]                 open = "w")
[01:29:13.922]         }
[01:29:13.922]         else {
[01:29:13.922]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:13.922]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:13.922]         }
[01:29:13.922]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:13.922]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:13.922]             base::sink(type = "output", split = FALSE)
[01:29:13.922]             base::close(...future.stdout)
[01:29:13.922]         }, add = TRUE)
[01:29:13.922]     }
[01:29:13.922]     ...future.frame <- base::sys.nframe()
[01:29:13.922]     ...future.conditions <- base::list()
[01:29:13.922]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:13.922]     if (FALSE) {
[01:29:13.922]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:13.922]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:13.922]     }
[01:29:13.922]     ...future.result <- base::tryCatch({
[01:29:13.922]         base::withCallingHandlers({
[01:29:13.922]             ...future.value <- base::withVisible(base::local({
[01:29:13.922]                 ...future.makeSendCondition <- base::local({
[01:29:13.922]                   sendCondition <- NULL
[01:29:13.922]                   function(frame = 1L) {
[01:29:13.922]                     if (is.function(sendCondition)) 
[01:29:13.922]                       return(sendCondition)
[01:29:13.922]                     ns <- getNamespace("parallel")
[01:29:13.922]                     if (exists("sendData", mode = "function", 
[01:29:13.922]                       envir = ns)) {
[01:29:13.922]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:13.922]                         envir = ns)
[01:29:13.922]                       envir <- sys.frame(frame)
[01:29:13.922]                       master <- NULL
[01:29:13.922]                       while (!identical(envir, .GlobalEnv) && 
[01:29:13.922]                         !identical(envir, emptyenv())) {
[01:29:13.922]                         if (exists("master", mode = "list", envir = envir, 
[01:29:13.922]                           inherits = FALSE)) {
[01:29:13.922]                           master <- get("master", mode = "list", 
[01:29:13.922]                             envir = envir, inherits = FALSE)
[01:29:13.922]                           if (inherits(master, c("SOCKnode", 
[01:29:13.922]                             "SOCK0node"))) {
[01:29:13.922]                             sendCondition <<- function(cond) {
[01:29:13.922]                               data <- list(type = "VALUE", value = cond, 
[01:29:13.922]                                 success = TRUE)
[01:29:13.922]                               parallel_sendData(master, data)
[01:29:13.922]                             }
[01:29:13.922]                             return(sendCondition)
[01:29:13.922]                           }
[01:29:13.922]                         }
[01:29:13.922]                         frame <- frame + 1L
[01:29:13.922]                         envir <- sys.frame(frame)
[01:29:13.922]                       }
[01:29:13.922]                     }
[01:29:13.922]                     sendCondition <<- function(cond) NULL
[01:29:13.922]                   }
[01:29:13.922]                 })
[01:29:13.922]                 withCallingHandlers({
[01:29:13.922]                   {
[01:29:13.922]                     3
[01:29:13.922]                   }
[01:29:13.922]                 }, immediateCondition = function(cond) {
[01:29:13.922]                   sendCondition <- ...future.makeSendCondition()
[01:29:13.922]                   sendCondition(cond)
[01:29:13.922]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.922]                   {
[01:29:13.922]                     inherits <- base::inherits
[01:29:13.922]                     invokeRestart <- base::invokeRestart
[01:29:13.922]                     is.null <- base::is.null
[01:29:13.922]                     muffled <- FALSE
[01:29:13.922]                     if (inherits(cond, "message")) {
[01:29:13.922]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:13.922]                       if (muffled) 
[01:29:13.922]                         invokeRestart("muffleMessage")
[01:29:13.922]                     }
[01:29:13.922]                     else if (inherits(cond, "warning")) {
[01:29:13.922]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:13.922]                       if (muffled) 
[01:29:13.922]                         invokeRestart("muffleWarning")
[01:29:13.922]                     }
[01:29:13.922]                     else if (inherits(cond, "condition")) {
[01:29:13.922]                       if (!is.null(pattern)) {
[01:29:13.922]                         computeRestarts <- base::computeRestarts
[01:29:13.922]                         grepl <- base::grepl
[01:29:13.922]                         restarts <- computeRestarts(cond)
[01:29:13.922]                         for (restart in restarts) {
[01:29:13.922]                           name <- restart$name
[01:29:13.922]                           if (is.null(name)) 
[01:29:13.922]                             next
[01:29:13.922]                           if (!grepl(pattern, name)) 
[01:29:13.922]                             next
[01:29:13.922]                           invokeRestart(restart)
[01:29:13.922]                           muffled <- TRUE
[01:29:13.922]                           break
[01:29:13.922]                         }
[01:29:13.922]                       }
[01:29:13.922]                     }
[01:29:13.922]                     invisible(muffled)
[01:29:13.922]                   }
[01:29:13.922]                   muffleCondition(cond)
[01:29:13.922]                 })
[01:29:13.922]             }))
[01:29:13.922]             future::FutureResult(value = ...future.value$value, 
[01:29:13.922]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:13.922]                   ...future.rng), globalenv = if (FALSE) 
[01:29:13.922]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:13.922]                     ...future.globalenv.names))
[01:29:13.922]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:13.922]         }, condition = base::local({
[01:29:13.922]             c <- base::c
[01:29:13.922]             inherits <- base::inherits
[01:29:13.922]             invokeRestart <- base::invokeRestart
[01:29:13.922]             length <- base::length
[01:29:13.922]             list <- base::list
[01:29:13.922]             seq.int <- base::seq.int
[01:29:13.922]             signalCondition <- base::signalCondition
[01:29:13.922]             sys.calls <- base::sys.calls
[01:29:13.922]             `[[` <- base::`[[`
[01:29:13.922]             `+` <- base::`+`
[01:29:13.922]             `<<-` <- base::`<<-`
[01:29:13.922]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:13.922]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:13.922]                   3L)]
[01:29:13.922]             }
[01:29:13.922]             function(cond) {
[01:29:13.922]                 is_error <- inherits(cond, "error")
[01:29:13.922]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:13.922]                   NULL)
[01:29:13.922]                 if (is_error) {
[01:29:13.922]                   sessionInformation <- function() {
[01:29:13.922]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:13.922]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:13.922]                       search = base::search(), system = base::Sys.info())
[01:29:13.922]                   }
[01:29:13.922]                   ...future.conditions[[length(...future.conditions) + 
[01:29:13.922]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:13.922]                     cond$call), session = sessionInformation(), 
[01:29:13.922]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:13.922]                   signalCondition(cond)
[01:29:13.922]                 }
[01:29:13.922]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:13.922]                 "immediateCondition"))) {
[01:29:13.922]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:13.922]                   ...future.conditions[[length(...future.conditions) + 
[01:29:13.922]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:13.922]                   if (TRUE && !signal) {
[01:29:13.922]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.922]                     {
[01:29:13.922]                       inherits <- base::inherits
[01:29:13.922]                       invokeRestart <- base::invokeRestart
[01:29:13.922]                       is.null <- base::is.null
[01:29:13.922]                       muffled <- FALSE
[01:29:13.922]                       if (inherits(cond, "message")) {
[01:29:13.922]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:13.922]                         if (muffled) 
[01:29:13.922]                           invokeRestart("muffleMessage")
[01:29:13.922]                       }
[01:29:13.922]                       else if (inherits(cond, "warning")) {
[01:29:13.922]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:13.922]                         if (muffled) 
[01:29:13.922]                           invokeRestart("muffleWarning")
[01:29:13.922]                       }
[01:29:13.922]                       else if (inherits(cond, "condition")) {
[01:29:13.922]                         if (!is.null(pattern)) {
[01:29:13.922]                           computeRestarts <- base::computeRestarts
[01:29:13.922]                           grepl <- base::grepl
[01:29:13.922]                           restarts <- computeRestarts(cond)
[01:29:13.922]                           for (restart in restarts) {
[01:29:13.922]                             name <- restart$name
[01:29:13.922]                             if (is.null(name)) 
[01:29:13.922]                               next
[01:29:13.922]                             if (!grepl(pattern, name)) 
[01:29:13.922]                               next
[01:29:13.922]                             invokeRestart(restart)
[01:29:13.922]                             muffled <- TRUE
[01:29:13.922]                             break
[01:29:13.922]                           }
[01:29:13.922]                         }
[01:29:13.922]                       }
[01:29:13.922]                       invisible(muffled)
[01:29:13.922]                     }
[01:29:13.922]                     muffleCondition(cond, pattern = "^muffle")
[01:29:13.922]                   }
[01:29:13.922]                 }
[01:29:13.922]                 else {
[01:29:13.922]                   if (TRUE) {
[01:29:13.922]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:13.922]                     {
[01:29:13.922]                       inherits <- base::inherits
[01:29:13.922]                       invokeRestart <- base::invokeRestart
[01:29:13.922]                       is.null <- base::is.null
[01:29:13.922]                       muffled <- FALSE
[01:29:13.922]                       if (inherits(cond, "message")) {
[01:29:13.922]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:13.922]                         if (muffled) 
[01:29:13.922]                           invokeRestart("muffleMessage")
[01:29:13.922]                       }
[01:29:13.922]                       else if (inherits(cond, "warning")) {
[01:29:13.922]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:13.922]                         if (muffled) 
[01:29:13.922]                           invokeRestart("muffleWarning")
[01:29:13.922]                       }
[01:29:13.922]                       else if (inherits(cond, "condition")) {
[01:29:13.922]                         if (!is.null(pattern)) {
[01:29:13.922]                           computeRestarts <- base::computeRestarts
[01:29:13.922]                           grepl <- base::grepl
[01:29:13.922]                           restarts <- computeRestarts(cond)
[01:29:13.922]                           for (restart in restarts) {
[01:29:13.922]                             name <- restart$name
[01:29:13.922]                             if (is.null(name)) 
[01:29:13.922]                               next
[01:29:13.922]                             if (!grepl(pattern, name)) 
[01:29:13.922]                               next
[01:29:13.922]                             invokeRestart(restart)
[01:29:13.922]                             muffled <- TRUE
[01:29:13.922]                             break
[01:29:13.922]                           }
[01:29:13.922]                         }
[01:29:13.922]                       }
[01:29:13.922]                       invisible(muffled)
[01:29:13.922]                     }
[01:29:13.922]                     muffleCondition(cond, pattern = "^muffle")
[01:29:13.922]                   }
[01:29:13.922]                 }
[01:29:13.922]             }
[01:29:13.922]         }))
[01:29:13.922]     }, error = function(ex) {
[01:29:13.922]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:13.922]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:13.922]                 ...future.rng), started = ...future.startTime, 
[01:29:13.922]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:13.922]             version = "1.8"), class = "FutureResult")
[01:29:13.922]     }, finally = {
[01:29:13.922]         if (!identical(...future.workdir, getwd())) 
[01:29:13.922]             setwd(...future.workdir)
[01:29:13.922]         {
[01:29:13.922]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:13.922]                 ...future.oldOptions$nwarnings <- NULL
[01:29:13.922]             }
[01:29:13.922]             base::options(...future.oldOptions)
[01:29:13.922]             if (.Platform$OS.type == "windows") {
[01:29:13.922]                 old_names <- names(...future.oldEnvVars)
[01:29:13.922]                 envs <- base::Sys.getenv()
[01:29:13.922]                 names <- names(envs)
[01:29:13.922]                 common <- intersect(names, old_names)
[01:29:13.922]                 added <- setdiff(names, old_names)
[01:29:13.922]                 removed <- setdiff(old_names, names)
[01:29:13.922]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:13.922]                   envs[common]]
[01:29:13.922]                 NAMES <- toupper(changed)
[01:29:13.922]                 args <- list()
[01:29:13.922]                 for (kk in seq_along(NAMES)) {
[01:29:13.922]                   name <- changed[[kk]]
[01:29:13.922]                   NAME <- NAMES[[kk]]
[01:29:13.922]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.922]                     next
[01:29:13.922]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:13.922]                 }
[01:29:13.922]                 NAMES <- toupper(added)
[01:29:13.922]                 for (kk in seq_along(NAMES)) {
[01:29:13.922]                   name <- added[[kk]]
[01:29:13.922]                   NAME <- NAMES[[kk]]
[01:29:13.922]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.922]                     next
[01:29:13.922]                   args[[name]] <- ""
[01:29:13.922]                 }
[01:29:13.922]                 NAMES <- toupper(removed)
[01:29:13.922]                 for (kk in seq_along(NAMES)) {
[01:29:13.922]                   name <- removed[[kk]]
[01:29:13.922]                   NAME <- NAMES[[kk]]
[01:29:13.922]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:13.922]                     next
[01:29:13.922]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:13.922]                 }
[01:29:13.922]                 if (length(args) > 0) 
[01:29:13.922]                   base::do.call(base::Sys.setenv, args = args)
[01:29:13.922]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:13.922]             }
[01:29:13.922]             else {
[01:29:13.922]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:13.922]             }
[01:29:13.922]             {
[01:29:13.922]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:13.922]                   0L) {
[01:29:13.922]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:13.922]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:13.922]                   base::options(opts)
[01:29:13.922]                 }
[01:29:13.922]                 {
[01:29:13.922]                   {
[01:29:13.922]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:13.922]                     NULL
[01:29:13.922]                   }
[01:29:13.922]                   options(future.plan = NULL)
[01:29:13.922]                   if (is.na(NA_character_)) 
[01:29:13.922]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:13.922]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:13.922]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:13.922]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:13.922]                     envir = parent.frame()) 
[01:29:13.922]                   {
[01:29:13.922]                     if (is.function(workers)) 
[01:29:13.922]                       workers <- workers()
[01:29:13.922]                     workers <- structure(as.integer(workers), 
[01:29:13.922]                       class = class(workers))
[01:29:13.922]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:13.922]                       workers >= 1)
[01:29:13.922]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:13.922]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:13.922]                     }
[01:29:13.922]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:13.922]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:13.922]                       envir = envir)
[01:29:13.922]                     if (!future$lazy) 
[01:29:13.922]                       future <- run(future)
[01:29:13.922]                     invisible(future)
[01:29:13.922]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:13.922]                 }
[01:29:13.922]             }
[01:29:13.922]         }
[01:29:13.922]     })
[01:29:13.922]     if (TRUE) {
[01:29:13.922]         base::sink(type = "output", split = FALSE)
[01:29:13.922]         if (TRUE) {
[01:29:13.922]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:13.922]         }
[01:29:13.922]         else {
[01:29:13.922]             ...future.result["stdout"] <- base::list(NULL)
[01:29:13.922]         }
[01:29:13.922]         base::close(...future.stdout)
[01:29:13.922]         ...future.stdout <- NULL
[01:29:13.922]     }
[01:29:13.922]     ...future.result$conditions <- ...future.conditions
[01:29:13.922]     ...future.result$finished <- base::Sys.time()
[01:29:13.922]     ...future.result
[01:29:13.922] }
[01:29:13.927] Poll #1 (0): usedNodes() = 2, workers = 2
[01:29:13.939] receiveMessageFromWorker() for ClusterFuture ...
[01:29:13.940] - Validating connection of MultisessionFuture
[01:29:13.940] - received message: FutureResult
[01:29:13.941] - Received FutureResult
[01:29:13.941] - Erased future from FutureRegistry
[01:29:13.941] result() for ClusterFuture ...
[01:29:13.941] - result already collected: FutureResult
[01:29:13.942] result() for ClusterFuture ... done
[01:29:13.942] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:13.942] result() for ClusterFuture ...
[01:29:13.942] - result already collected: FutureResult
[01:29:13.943] result() for ClusterFuture ... done
[01:29:13.943] result() for ClusterFuture ...
[01:29:13.943] - result already collected: FutureResult
[01:29:13.943] result() for ClusterFuture ... done
[01:29:13.946] MultisessionFuture started
[01:29:13.946] - Launch lazy future ... done
[01:29:13.946] run() for 'MultisessionFuture' ... done
[01:29:13.947] resolve() on list environment ...
[01:29:13.947]  recursive: 0
[01:29:13.948]  length: 4
[01:29:13.948]  elements: 'a', 'b', 'c', 'd'
[01:29:13.949] Future #1
[01:29:13.949]  length: 3 (resolved future 1)
[01:29:14.142] receiveMessageFromWorker() for ClusterFuture ...
[01:29:14.143] - Validating connection of MultisessionFuture
[01:29:14.143] - received message: FutureResult
[01:29:14.143] - Received FutureResult
[01:29:14.144] - Erased future from FutureRegistry
[01:29:14.144] result() for ClusterFuture ...
[01:29:14.144] - result already collected: FutureResult
[01:29:14.144] result() for ClusterFuture ... done
[01:29:14.144] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:14.145] Future #3
[01:29:14.145]  length: 2 (resolved future 3)
[01:29:14.145]  length: 1 (resolved future 4)
[01:29:14.426] receiveMessageFromWorker() for ClusterFuture ...
[01:29:14.426] - Validating connection of MultisessionFuture
[01:29:14.427] - received message: FutureResult
[01:29:14.427] - Received FutureResult
[01:29:14.427] - Erased future from FutureRegistry
[01:29:14.427] result() for ClusterFuture ...
[01:29:14.428] - result already collected: FutureResult
[01:29:14.428] result() for ClusterFuture ... done
[01:29:14.428] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:14.428] Future #2
[01:29:14.428]  length: 0 (resolved future 2)
[01:29:14.429] resolve() on list environment ... DONE
[01:29:14.429] resolve() on list environment ...
[01:29:14.429]  recursive: 0
[01:29:14.430]  length: 4
[01:29:14.430]  elements: 'a', 'b', 'c', 'd'
[01:29:14.431] Future #1
[01:29:14.431]  length: 3 (resolved future 1)
[01:29:14.431] Future #2
[01:29:14.431]  length: 2 (resolved future 2)
[01:29:14.432] Future #3
[01:29:14.432]  length: 1 (resolved future 3)
[01:29:14.432]  length: 0 (resolved future 4)
[01:29:14.432] resolve() on list environment ... DONE
[01:29:14.433] resolve() on list environment ...
[01:29:14.433]  recursive: 0
[01:29:14.434]  length: 4
[01:29:14.434]  elements: 'a', 'b', 'c', 'd'
[01:29:14.434] Future #1
[01:29:14.434]  length: 3 (resolved future 1)
[01:29:14.434] Future #2
[01:29:14.435]  length: 2 (resolved future 2)
[01:29:14.435] Future #3
[01:29:14.435]  length: 1 (resolved future 3)
[01:29:14.435]  length: 0 (resolved future 4)
[01:29:14.435] resolve() on list environment ... DONE
[01:29:14.436] resolve() on list environment ...
[01:29:14.436]  recursive: 0
[01:29:14.437]  length: 4
[01:29:14.437]  elements: 'a', 'b', 'c', 'd'
[01:29:14.437] Future #1
[01:29:14.437]  length: 3 (resolved future 1)
[01:29:14.438] Future #2
[01:29:14.438]  length: 2 (resolved future 2)
[01:29:14.438] Future #3
[01:29:14.438]  length: 1 (resolved future 3)
[01:29:14.439]  length: 0 (resolved future 4)
[01:29:14.439] resolve() on list environment ... DONE
[01:29:14.440] resolve() on list environment ...
[01:29:14.440]  recursive: 0
[01:29:14.440]  length: 4
[01:29:14.441]  elements: 'a', 'b', 'c', 'd'
[01:29:14.441] Future #1
[01:29:14.441] result() for ClusterFuture ...
[01:29:14.441] - result already collected: FutureResult
[01:29:14.441] result() for ClusterFuture ... done
[01:29:14.442] result() for ClusterFuture ...
[01:29:14.442] - result already collected: FutureResult
[01:29:14.442] result() for ClusterFuture ... done
[01:29:14.442]  length: 3 (resolved future 1)
[01:29:14.442] Future #2
[01:29:14.442] result() for ClusterFuture ...
[01:29:14.443] - result already collected: FutureResult
[01:29:14.443] result() for ClusterFuture ... done
[01:29:14.443] result() for ClusterFuture ...
[01:29:14.443] - result already collected: FutureResult
[01:29:14.443] result() for ClusterFuture ... done
[01:29:14.444]  length: 2 (resolved future 2)
[01:29:14.444] Future #3
[01:29:14.444] result() for ClusterFuture ...
[01:29:14.444] - result already collected: FutureResult
[01:29:14.444] result() for ClusterFuture ... done
[01:29:14.444] result() for ClusterFuture ...
[01:29:14.445] - result already collected: FutureResult
[01:29:14.445] result() for ClusterFuture ... done
[01:29:14.445]  length: 1 (resolved future 3)
[01:29:14.445]  length: 0 (resolved future 4)
[01:29:14.445] resolve() on list environment ... DONE
[01:29:14.446] resolve() on list environment ...
[01:29:14.446]  recursive: 99
[01:29:14.447]  length: 4
[01:29:14.447]  elements: 'a', 'b', 'c', 'd'
[01:29:14.451] Future #1
[01:29:14.452] result() for ClusterFuture ...
[01:29:14.452] - result already collected: FutureResult
[01:29:14.452] result() for ClusterFuture ... done
[01:29:14.452] result() for ClusterFuture ...
[01:29:14.452] - result already collected: FutureResult
[01:29:14.453] result() for ClusterFuture ... done
[01:29:14.453] A MultisessionFuture was resolved
[01:29:14.453]  length: 3 (resolved future 1)
[01:29:14.453] Future #2
[01:29:14.453] result() for ClusterFuture ...
[01:29:14.453] - result already collected: FutureResult
[01:29:14.454] result() for ClusterFuture ... done
[01:29:14.454] result() for ClusterFuture ...
[01:29:14.454] - result already collected: FutureResult
[01:29:14.454] result() for ClusterFuture ... done
[01:29:14.455] A MultisessionFuture was resolved
[01:29:14.455]  length: 2 (resolved future 2)
[01:29:14.455] Future #3
[01:29:14.455] result() for ClusterFuture ...
[01:29:14.455] - result already collected: FutureResult
[01:29:14.456] result() for ClusterFuture ... done
[01:29:14.456] result() for ClusterFuture ...
[01:29:14.456] - result already collected: FutureResult
[01:29:14.456] result() for ClusterFuture ... done
[01:29:14.456] A MultisessionFuture was resolved
[01:29:14.456]  length: 1 (resolved future 3)
[01:29:14.457]  length: 0 (resolved future 4)
[01:29:14.457] 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)
[01:29:14.461] resolve() on list ...
[01:29:14.461]  recursive: 0
[01:29:14.461]  length: 3
[01:29:14.461] 
[01:29:14.462]  length: 2 (resolved future 1)
[01:29:14.462]  length: 1 (resolved future 2)
[01:29:14.462]  length: 0 (resolved future 3)
[01:29:14.462] 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")
[01:29:14.463] plan(): Setting new future strategy stack:
[01:29:14.464] List of future strategies:
[01:29:14.464] 1. FutureStrategy:
[01:29:14.464]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:14.464]    - tweaked: FALSE
[01:29:14.464]    - call: future::plan(oplan)
[01:29:14.465] plan(): nbrOfWorkers() = 1
Failed to undo environment variables:
 - Expected environment variables: [n=204] '!ExitCode', 'ALLUSERSPROFILE', 'APPDATA', 'BIBINPUTS', 'BINDIR', 'BSTINPUTS', 'COMMONPROGRAMFILES', 'COMPUTERNAME', 'COMSPEC', 'CURL_CA_BUNDLE', 'CYGWIN', 'CommonProgramFiles(x86)', 'CommonProgramW6432', 'DriverData', 'HOME', 'HOMEDRIVE', 'HOMEPATH', 'JAGS_ROOT', 'JAVA_HOME', 'LANGUAGE', 'LC_COLLATE', 'LC_MONETARY', 'LC_TIME', 'LOCALAPPDATA', 'LOGONSERVER', 'LS_HOME', 'LS_LICENSE_PATH', 'MAKE', 'MAKEFLAGS', 'MAKELEVEL', 'MFLAGS', 'MSMPI_BENCHMARKS', 'MSMPI_BIN', 'MSYS2_ENV_CONV_EXCL', 'NUMBER_OF_PROCESSORS', 'OCL', 'OMP_THREAD_LIMIT', 'OS', 'PATH', 'PATHEXT', 'PROCESSOR_ARCHITECTURE', 'PROCESSOR_IDENTIFIER', 'PROCESSOR_LEVEL', 'PROCESSOR_REVISION', 'PROGRAMFILES', 'PROMPT', 'PSModulePath', 'PUBLIC', 'PWD', 'ProgramData', 'ProgramFiles(x86)', 'ProgramW6432', 'RTOOLS43_HOME', 'R_ARCH', 'R_BROWSER', 'R_BZIPCMD', 'R_CMD', 'R_COMPILED_BY', 'R_CRAN_WEB', 'R_CUSTOM_TOOLS_PATH', 'R_CUSTOM_TOOLS_SOFT', 'R_DOC_DIR', 'R_ENVIRON_USER', 'R_GSCMD', 'R_GZIPCMD', 'R_HOME', 'R_INCLUDE_DIR', 'R_INSTALL_TAR', 'R_LIBS', 'R_LIBS_SITE', 'R_LIBS_USER', 'R_MAX_NUM_DLLS', 'R_OSTYPE', 'R_PAPERSIZE', 'R_PAPERSIZE_USER', 'R_PARALLELLY_MAKENODEPSOCK_AUTOKILL', 'R_PARALLELLY_MAKENODEPSOCK_CONNECTTIMEOUT', 'R_PARALLELLY_MAKENODEPSOCK_RSCRIPT_LABEL', 'R_PARALLELLY_MAKENODEPSOCK_SESSIONINFO_PKGS', 'R_PARALLELLY_MAKENODEPSOCK_TIMEOUT', 'R_PARALLELLY_RANDOM_PORTS', 'R_PARALLEL_PORT', 'R_RD4PDF', 'R_RTOOLS43_PATH', 'R_SCRIPT_LEGACY', 'R_SHARE_DIR', 'R_TESTS', 'R_UNZIPCMD', 'R_USER', 'R_VERSION', 'R_ZIPCMD', 'SED', 'SHLVL', 'SYSTEMDRIVE', 'SYSTEMROOT', 'TAR', 'TAR_OPTIONS', 'TEMP', 'TERM', 'TEXINPUTS', 'TMP', 'TMPDIR', 'USERDOMAIN', 'USERDOMAIN_ROAMINGPROFILE', 'USERNAME', 'USERPROFILE', 'WINDIR', '_', '_R_CHECK_AUTOCONF_', '_R_CHECK_BOGUS_RETURN_', '_R_CHECK_BROWSER_NONINTERACTIVE_', '_R_CHECK_BUILD_VIGNETTES_SEPARATELY_', '_R_CHECK_CODETOOLS_PROFILE_', '_R_CHECK_CODE_ASSIGN_TO_GLOBALENV_', '_R_CHECK_CODE_ATTACH_', '_R_CHECK_CODE_CLASS_IS_STRING_', '_R_CHECK_CODE_DATA_INTO_GLOBALENV_', '_R_CHECK_CODE_USAGE_VIA_NAMESPACES_', '_R_CHECK_CODE_USAGE_WITHOUT_LOADING_', '_R_CHECK_CODE_USAGE_WITH_ONLY_BASE_ATTACHED_', '_R_CHECK_CODOC_VARIABLES_IN_USAGES_', '_R_CHECK_COMPACT_DATA2_', '_R_CHECK_COMPILATION_FLAGS_', '_R_CHECK_CONNECTIONS_LEFT_OPEN_', '_R_CHECK_CRAN_INCOMING_', '_R_CHECK_CRAN_INCOMING_CHECK_FILE_URIS_', '_R_CHECK_CRAN_INCOMING_CHECK_URLS_IN_PARALLEL_', '_R_CHECK_CRAN_INCOMING_NOTE_GNU_MAKE_', '_R_CHECK_CRAN_INCOMING_REMOTE_', '_R_CHECK_CRAN_INCOMING_USE_ASPELL_', '_R_CHECK_DATALIST_', '_R_CHECK_DEPRECATED_DEFUNCT_', '_R_CHECK_DOC_SIZES2_', '_R_CHECK_DOT_FIRSTLIB_', '_R_CHECK_DOT_INTERNAL_', '_R_CHECK_EXAMPLE_TIMING_THRESHOLD_', '_R_CHECK_EXECUTABLES_', '_R_CHECK_EXECUTABLES_EXCLUSIONS_', '_R_CHECK_FF_CALLS_', '_R_CHECK_FF_DUP_', '_R_CHECK_FORCE_SUGGESTS_', '_R_CHECK_FUTURE_FILE_TIMESTAMPS_', '_R_CHECK_FUTURE_FILE_TIMESTAMPS_LEEWAY_', '_R_CHECK_HAVE_MYSQL_', '_R_CHECK_HAVE_ODBC_', '_R_CHECK_HAVE_PERL_', '_R_CHECK_HAVE_POSTGRES_', '_R_CHECK_INSTALL_DEPENDS_', '_R_CHECK_INTERNALS2_', '_R_CHECK_LENGTH_1_CONDITION_', '_R_CHECK_LICENSE_', '_R_CHECK_LIMIT_CORES_', '_R_CHECK_MATRIX_DATA_', '_R_CHECK_MBCS_CONVERSION_FAILURE_', '_R_CHECK_NATIVE_ROUTINE_REGISTRATION_', '_R_CHECK_NEWS_IN_PLAIN_TEXT_', '_R_CHECK_NO_RECOMMENDED_', '_R_CHECK_NO_STOP_ON_TEST_ERROR_', '_R_CHECK_ORPHANED_', '_R_CHECK_OVERWRITE_REGISTERED_S3_METHODS_', '_R_CHECK_PACKAGES_USED_IGNORE_UNUSED_IMPORTS_', '_R_CHECK_PACKAGES_USED_IN_TESTS_USE_SUBDIRS_', '_R_CHECK_PACKAGE_DATASETS_SUPPRESS_NOTES_', '_R_CHECK_PACKAGE_NAME_', '_R_CHECK_PKG_SIZES_', '_R_CHECK_PKG_SIZES_THRESHOLD_', '_R_CHECK_PRAGMAS_', '_R_CHECK_RD_EXAMPLES_T_AND_F_', '_R_CHECK_RD_LINE_WIDTHS_', '_R_CHECK_RD_MATH_RENDERING_', '_R_CHECK_RD_NOTE_LOST_BRACES_', '_R_CHECK_RD_VALIDATE_RD2HTML_', '_R_CHECK_REPLACING_IMPORTS_', '_R_CHECK_R_DEPENDS_', '_R_CHECK_S3_METHODS_SHOW_POSSIBLE_ISSUES_', '_R_CHECK_SCREEN_DEVICE_', '_R_CHECK_SERIALIZATION_', '_R_CHECK_SHLIB_OPENMP_FLAGS_', '_R_CHECK_SRC_MINUS_W_IMPLICIT_', '_R_CHECK_SUBDIRS_NOCASE_', '_R_CHECK_SUBDIRS_STRICT_', '_R_CHECK_SUGGESTS_ONLY_', '_R_CHECK_SYSTEM_CLOCK_', '_R_CHECK_TESTS_NLINES_', '_R_CHECK_TEST_TIMING_', '_R_CHECK_TIMINGS_', '_R_CHECK_TOPLEVEL_FILES_', '_R_CHECK_UNDOC_USE_ALL_NAMES_', '_R_CHECK_UNSAFE_CALLS_', '_R_CHECK_URLS_SHOW_301_STATUS_', '_R_CHECK_VC_DIRS_', '_R_CHECK_VIGNETTES_NLINES_', '_R_CHECK_VIGNETTES_SKIP_RUN_MAYBE_', '_R_CHECK_VIGNETTE_TIMING_', '_R_CHECK_VIGNETTE_TITLES_', '_R_CHECK_WINDOWS_DEVICE_', '_R_CHECK_XREFS_USE_ALIASES_FROM_CRAN_', '_R_CLASS_MATRIX_ARRAY_', '_R_INSTALL_TIME_PATCHES_', '_R_S3_METHOD_LOOKUP_BASEENV_AFTER_GLOBALENV_', '_R_SHLIB_BUILD_OBJECTS_SYMBOL_TABLES_', '__R_CHECK_DOC_FILES_NOTE_IF_ALL_SPECIAL__', 'maj.version', 'nextArg--timingsnextArg--install'
 - Environment variables still there: [n=0] 
 - Environment variables missing: [n=1] 'MAKEFLAGS'
Differences environment variable by environment variable:
List of 3
 $ name    : chr "MAKEFLAGS"
 $ expected: 'Dlist' chr ""
 $ actual  : 'Dlist' chr NA
> 
> proc.time()
   user  system elapsed 
   4.07    0.18   22.31